Upload ScaleBench dataset

.gitattributes

@@ -1,6 +1,5 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,320 @@
----
-license: mit
----
+---
+license: cc-by-4.0
+language:
+- en
+pretty_name: Budget-Efficient Scaling Law Fitting Benchmark
+task_categories:
+- tabular-regression
+tags:
+- scaling-laws
+- active-learning
+- experimental-design
+- benchmark
+- language-modeling
+size_categories:
+- 1K<n<10K
+dataset_info:
+- config_name: data_constrained_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: unique_tokens
+    dtype: float64
+  - name: params
+    dtype: float64
+  - name: tokens
+    dtype: float64
+  - name: loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 161
+  - name: test
+    num_examples: 21
+- config_name: domain_mixture_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: proportion_domain_1
+    dtype: float64
+  - name: proportion_domain_2
+    dtype: float64
+  - name: proportion_domain_3
+    dtype: float64
+  - name: proportion_domain_4
+    dtype: float64
+  - name: proportion_domain_5
+    dtype: float64
+  - name: loss_domain_1
+    dtype: float64
+  - name: loss_domain_2
+    dtype: float64
+  - name: loss_domain_3
+    dtype: float64
+  - name: loss_domain_4
+    dtype: float64
+  - name: loss_domain_5
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 80
+  - name: test
+    num_examples: 24
+- config_name: farseer_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: N
+    dtype: float64
+  - name: D
+    dtype: float64
+  - name: loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 404
+  - name: test
+    num_examples: 7
+- config_name: lr_bsz_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: lr
+    dtype: float64
+  - name: bsz
+    dtype: float64
+  - name: data_size
+    dtype: float64
+  - name: non_embedding_param_size
+    dtype: float64
+  - name: lm_loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 2702
+  - name: test
+    num_examples: 117
+- config_name: moe_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: num_experts
+    dtype: float64
+  - name: dense_parameter_count
+    dtype: float64
+  - name: loss_validation
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 193
+  - name: test
+    num_examples: 28
+- config_name: parallel_scaling_law
+  features:
+  - name: num_params
+    dtype: int64
+  - name: parallel_size
+    dtype: int64
+  - name: group
+    dtype: string
+  - name: loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 36
+  - name: test
+    num_examples: 12
+- config_name: sparsity_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: P
+    dtype: float64
+  - name: N_active
+    dtype: float64
+  - name: N_dense
+    dtype: float64
+  - name: D1
+    dtype: float64
+  - name: D2
+    dtype: float64
+  - name: loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 70
+  - name: test
+    num_examples: 18
+- config_name: vocab_scaling_law
+  features:
+  - name: group
+    dtype: string
+  - name: non_vocab_parameters
+    dtype: float64
+  - name: vocab_size
+    dtype: float64
+  - name: num_characters
+    dtype: float64
+  - name: unigram_normalized_loss
+    dtype: float64
+  splits:
+  - name: train
+    num_examples: 1080
+  - name: test
+    num_examples: 120
+configs:
+- config_name: data_constrained_scaling_law
+  data_files:
+  - split: train
+    path: data_constrained_scaling_law/train-*
+  - split: test
+    path: data_constrained_scaling_law/test-*
+- config_name: domain_mixture_scaling_law
+  data_files:
+  - split: train
+    path: domain_mixture_scaling_law/train-*
+  - split: test
+    path: domain_mixture_scaling_law/test-*
+- config_name: farseer_scaling_law
+  data_files:
+  - split: train
+    path: farseer_scaling_law/train-*
+  - split: test
+    path: farseer_scaling_law/test-*
+- config_name: lr_bsz_scaling_law
+  data_files:
+  - split: train
+    path: lr_bsz_scaling_law/train-*
+  - split: test
+    path: lr_bsz_scaling_law/test-*
+- config_name: moe_scaling_law
+  data_files:
+  - split: train
+    path: moe_scaling_law/train-*
+  - split: test
+    path: moe_scaling_law/test-*
+- config_name: parallel_scaling_law
+  data_files:
+  - split: train
+    path: parallel_scaling_law/train-*
+  - split: test
+    path: parallel_scaling_law/test-*
+- config_name: sparsity_scaling_law
+  data_files:
+  - split: train
+    path: sparsity_scaling_law/train-*
+  - split: test
+    path: sparsity_scaling_law/test-*
+- config_name: vocab_scaling_law
+  data_files:
+  - split: train
+    path: vocab_scaling_law/train-*
+  - split: test
+    path: vocab_scaling_law/test-*
+---
+
+# Budget-Efficient Scaling Law Fitting Benchmark
+
+This repository contains the scaling-law benchmark dataset used in
+[Spend Less, Fit Better: Budget-Efficient Scaling Law Fitting via Active Experiment Selection](https://arxiv.org/abs/2604.22753).
+
+The benchmark is designed for budget-aware sequential experimental design in scaling-law fitting. Each configuration provides a finite pool of candidate experiments, a held-out high-cost target region, task-specific covariates, observed outcomes, and companion scaling-law definitions in `laws.py`.
+
+## Dataset Summary
+
+The dataset contains 8 tabular regression tasks and 65 scaling-law instances. The tasks cover language-model scaling settings including pre-training hyperparameter tuning, data allocation, vocabulary design, domain mixture optimization, mixture-of-experts design, sparsity, parallel/inference-time scaling, and Farseer-style dense pre-training scaling.
+
+Each task is stored as a separate Hugging Face configuration with `train` and `test` splits:
+
+| Config | Train | Test | Feature columns | Target column(s) | Law instances |
+|---|---:|---:|---|---|---:|
+| `data_constrained_scaling_law` | 161 | 21 | `unique_tokens`, `params`, `tokens` | `loss` | 10 |
+| `domain_mixture_scaling_law` | 80 | 24 | `proportion_domain_1` ... `proportion_domain_5` | `loss_domain_1` ... `loss_domain_5` | 10 |
+| `farseer_scaling_law` | 404 | 7 | `N`, `D` | `loss` | 1 |
+| `lr_bsz_scaling_law` | 2702 | 117 | `lr`, `bsz`, `data_size`, `non_embedding_param_size` | `lm_loss` | 10 |
+| `moe_scaling_law` | 193 | 28 | `num_experts`, `dense_parameter_count` | `loss_validation` | 10 |
+| `parallel_scaling_law` | 36 | 12 | `num_params`, `parallel_size` | `loss` | 10 |
+| `sparsity_scaling_law` | 70 | 18 | `P`, `N_active` | `loss` | 4 |
+| `vocab_scaling_law` | 1080 | 120 | `non_vocab_parameters`, `vocab_size`, `num_characters` | `unigram_normalized_loss` | 10 |
+
+The `group` column identifies a task-specific subproblem or grouping. For example, domain-mixture rows are grouped by model scale, and parallel-scaling rows are grouped by evaluation corpus.
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("sijieli/scalebench", "lr_bsz_scaling_law")
+print(ds)
+print(ds["train"][0])
+```
+
+To load a local checkout before uploading:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset(
+    "parquet",
+    data_files={
+        "train": "lr_bsz_scaling_law/train-*.parquet",
+        "test": "lr_bsz_scaling_law/test-*.parquet",
+    },
+)
+```
+
+## Intended Use
+
+This benchmark is intended for evaluating experiment-selection and active experimental-design methods for scaling-law fitting under budget constraints. A typical episode treats the `train` split as the candidate pool of runnable experiments and the `test` split as the target region for extrapolation evaluation.
+
+The benchmark can be used to compare methods that:
+
+- choose experiments sequentially under a cost budget;
+- fit nonlinear scaling laws from sparse observations;
+- extrapolate to held-out high-cost regions;
+- optimize target-region prediction quality rather than in-sample fit.
+
+## Cost Proxies
+
+The paper uses task-specific cost proxies to model heterogeneous experiment costs. The implementation in `registry.py` defines the default proxies:
+
+| Config | Cost proxy |
+|---|---|
+| `data_constrained_scaling_law` | `6 * params * tokens` |
+| `domain_mixture_scaling_law` | `1` |
+| `farseer_scaling_law` | `6 * N * D` |
+| `lr_bsz_scaling_law` | `6 * non_embedding_param_size * data_size` |
+| `moe_scaling_law` | `dense_parameter_count * num_experts` |
+| `parallel_scaling_law` | `num_params` |
+| `sparsity_scaling_law` | `6 * N_dense * D1 + 6 * N_active * D2` |
+| `vocab_scaling_law` | `non_vocab_parameters * num_characters` |
+
+## Scaling-Law Definitions
+
+Each task directory includes a `laws.py` file containing the parametric scaling-law families used in the benchmark. The functions are named `sl_1`, `sl_2`, etc., and each file exposes:
+
+- `LAW_REGISTRY`: mapping from law ID to callable;
+- `PARAM_COUNTS`: number of free parameters for each law;
+- parameter bounds used by the fitting code.
+
+These files are included to make the dataset self-contained for reproducing the benchmark protocol.
+
+## Citation
+
+If you use this benchmark, please cite:
+
+```bibtex
+@misc{li2026spendlessfitbetter,
+  title={Spend Less, Fit Better: Budget-Efficient Scaling Law Fitting via Active Experiment Selection},
+  author={Sijie Li and Shanda Li and Haowei Lin and Weiwei Sun and Ameet Talwalkar and Yiming Yang},
+  year={2026},
+  eprint={2604.22753},
+  archivePrefix={arXiv},
+  primaryClass={cs.LG},
+  url={https://arxiv.org/abs/2604.22753}
+}
+```
+
+## License
+
+This dataset card follows the license metadata declared for this repository. Users should also respect the licenses and terms of the original data sources referenced by the paper.

data_constrained_scaling_law/laws.py

@@ -0,0 +1,941 @@
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+_M_REF = 1.0
+_T_REF = 1.0
+_U_REF = 1.0
+
+# Scaling law 1:
+#   A / N^alpha + B / D^beta + E * (U^gamma * N^delta)
+# theta: [A, alpha, B, beta, E, gamma, delta]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    # X: (M, 3)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+
+    # theta: (B, 7)
+    A = theta[:, 0]
+    alpha = theta[:, 1]
+    Bcoef = theta[:, 2]
+    beta = theta[:, 3]
+    Ecoef = theta[:, 4]
+    gamma = theta[:, 5]
+    delta = theta[:, 6]
+
+    N_b = N[None, :]  # (1, M)
+    D_b = D[None, :]
+    U_b = U[None, :]
+
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+    log_U = xp.log(ops.clamp_min(U_b, _EPS))
+
+    N_neg_alpha = N_b ** (-alpha[:, None])          # (B, M)
+    D_neg_beta = D_b ** (-beta[:, None])             # (B, M)
+    U_gamma = U_b ** gamma[:, None]                  # (B, M)
+    N_delta = N_b ** delta[:, None]                  # (B, M)
+
+    term1 = A[:, None] * N_neg_alpha                 # (B, M)
+    term2 = Bcoef[:, None] * D_neg_beta              # (B, M)
+    term3 = Ecoef[:, None] * U_gamma * N_delta       # (B, M)
+
+    pred = term1 + term2 + term3
+
+    # Jacobian: (B, M, 7)
+    d_A = N_neg_alpha                                # ∂/∂A = N^(-alpha)
+    d_alpha = -term1 * log_N                         # ∂/∂alpha = -A*N^(-alpha)*log(N)
+    d_B = D_neg_beta                                 # ∂/∂B = D^(-beta)
+    d_beta = -term2 * log_D                          # ∂/∂beta = -B*D^(-beta)*log(D)
+    d_E = U_gamma * N_delta                          # ∂/∂E = U^gamma * N^delta
+    d_gamma = term3 * log_U                          # ∂/∂gamma = term3 * log(U)
+    d_delta = term3 * log_N                          # ∂/∂delta = term3 * log(N)
+
+    jac = ops.stack([d_A, d_alpha, d_B, d_beta, d_E, d_gamma, d_delta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+# Scaling law 2:
+#   a + b * U^p + c * N^q + d * D^r
+# theta: [a, b, c, d, p, q, r]
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    # X: (M, 3)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+
+    # theta: (B, 7)
+    a0 = theta[:, 0]
+    bcoef = theta[:, 1]
+    ccoef = theta[:, 2]
+    dcoef = theta[:, 3]
+    p = theta[:, 4]
+    q = theta[:, 5]
+    r = theta[:, 6]
+
+    U_b = U[None, :]
+    N_b = N[None, :]
+    D_b = D[None, :]
+
+    log_U = xp.log(ops.clamp_min(U_b, _EPS))
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+
+    U_p = U_b ** p[:, None]        # (B, M)
+    N_q = N_b ** q[:, None]        # (B, M)
+    D_r = D_b ** r[:, None]        # (B, M)
+
+    term2 = bcoef[:, None] * U_p
+    term3 = ccoef[:, None] * N_q
+    term4 = dcoef[:, None] * D_r
+
+    pred = a0[:, None] + term2 + term3 + term4
+
+    # Jacobian: (B, M, 7)
+    ones = pred * 0.0 + 1.0
+    d_a = ones                         # ∂/∂a = 1
+    d_b = U_p                          # ∂/∂b = U^p
+    d_c = N_q                          # ∂/∂c = N^q
+    d_d = D_r                          # ∂/∂d = D^r
+    d_p = term2 * log_U                # ∂/∂p = b*U^p*log(U)
+    d_q = term3 * log_N                # ∂/∂q = c*N^q*log(N)
+    d_r = term4 * log_D                # ∂/∂r = d*D^r*log(D)
+
+    jac = ops.stack([d_a, d_b, d_c, d_d, d_p, d_q, d_r], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+# Scaling law 3 (data-constrained style):
+#   loss = A / eff_N^alpha + B / eff_D^alpha + C
+# where
+#   U_D = U
+#   R_D = D / U_D - 1
+#   U_N = min(rho * U_D, N)
+#   R_N = max(N / U_N - 1, 0)
+#   eff_N = U_N + tau_N * U_N * (1 - exp(-R_N / tau_N))
+#   eff_D = U_D + tau_D * U_D * (1 - exp(-R_D / tau_D))
+#
+# theta: [A, tau_N, B, tau_D, alpha, C, rho]
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    # X: (M, 3)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+
+    # theta: (B, 7)
+    A = theta[:, 0]
+    tau_N = theta[:, 1]
+    Bcoef = theta[:, 2]
+    tau_D = theta[:, 3]
+    alpha = theta[:, 4]
+    C = theta[:, 5]
+    rho = theta[:, 6]
+
+    U_b = U[None, :]   # (1, M)
+    N_b = N[None, :]
+    D_b = D[None, :]
+
+    # avoid divide-by-zero
+    U_D = ops.clamp_min(U_b, _EPS)
+
+    R_D = D_b / U_D - 1.0                            # (1, M) or (B, M)
+
+    rho_U_D = rho[:, None] * U_D                      # (B, M)
+    U_N_raw = ops.minimum(rho_U_D, N_b)               # (B, M)
+    U_N = ops.clamp_min(U_N_raw, _EPS)
+
+    R_N_raw = N_b / U_N - 1.0
+    R_N = ops.clamp_min(R_N_raw, 0.0)                 # (B, M)
+
+    tau_N_b = tau_N[:, None]                           # (B, 1)
+    tau_D_b = tau_D[:, None]
+
+    exp_RN = ops.exp(-R_N / tau_N_b)                   # (B, M)
+    exp_RD = ops.exp(-R_D / tau_D_b)                   # (B, M)
+
+    eff_N_raw = U_N + tau_N_b * U_N * (1.0 - exp_RN)   # (B, M)
+    eff_D_raw = U_D + tau_D_b * U_D * (1.0 - exp_RD)   # (B, M)
+
+    # Masks for clamp: derivative is 0 where clamp is active
+    mask_eff_N = (eff_N_raw > _EPS) * 1.0               # (B, M)
+    mask_eff_D = (eff_D_raw > _EPS) * 1.0               # (B, M)
+
+    eff_N = ops.clamp_min(eff_N_raw, _EPS)
+    eff_D = ops.clamp_min(eff_D_raw, _EPS)
+
+    log_eff_N = xp.log(ops.clamp_min(eff_N, _EPS))
+    log_eff_D = xp.log(ops.clamp_min(eff_D, _EPS))
+
+    eff_N_neg_alpha = eff_N ** (-alpha[:, None])       # (B, M)
+    eff_D_neg_alpha = eff_D ** (-alpha[:, None])       # (B, M)
+
+    termN = A[:, None] * eff_N_neg_alpha               # (B, M)
+    termD = Bcoef[:, None] * eff_D_neg_alpha           # (B, M)
+
+    pred = termN + termD + C[:, None]
+
+    # --- Jacobian ---
+    # ∂pred/∂A = eff_N^(-alpha)
+    d_A = eff_N_neg_alpha
+
+    # ∂pred/∂B = eff_D^(-alpha)
+    d_B = eff_D_neg_alpha
+
+    # ∂pred/∂alpha = -termN * log(eff_N) - termD * log(eff_D)
+    d_alpha = -termN * log_eff_N - termD * log_eff_D
+
+    # ∂pred/∂C = 1
+    ones = pred * 0.0 + 1.0
+    d_C = ones
+
+    # For tau_N: ∂pred/∂tau_N = ∂pred/∂eff_N * ∂eff_N/∂tau_N
+    # ∂pred/∂eff_N = -alpha * A * eff_N^(-alpha-1) = -alpha * termN / eff_N
+    dpred_deffN = -alpha[:, None] * termN / eff_N      # (B, M)
+
+    # ∂eff_N/∂tau_N = U_N * (1 - exp(-R_N/tau_N) - (R_N/tau_N)*exp(-R_N/tau_N))
+    #               = U_N * (1 - exp_RN - (R_N/tau_N)*exp_RN)
+    #               = U_N * (1 - exp_RN*(1 + R_N/tau_N))
+    deffN_dtauN = U_N * (1.0 - exp_RN * (1.0 + R_N / tau_N_b))  # (B, M)
+    d_tau_N = dpred_deffN * deffN_dtauN * mask_eff_N
+
+    # For tau_D: ∂pred/∂tau_D = ∂pred/∂eff_D * ∂eff_D/∂tau_D
+    dpred_deffD = -alpha[:, None] * termD / eff_D      # (B, M)
+    deffD_dtauD = U_D * (1.0 - exp_RD * (1.0 + R_D / tau_D_b))  # (B, M)
+    d_tau_D = dpred_deffD * deffD_dtauD * mask_eff_D
+
+    # For rho: ∂pred/∂rho = ∂pred/∂eff_N * ∂eff_N/∂U_N * ∂U_N/∂rho
+    # + ∂pred/∂eff_N * ∂eff_N/∂R_N * ∂R_N/∂U_N * ∂U_N/∂rho
+    #
+    # U_N = min(rho*U_D, N). ∂U_N/∂rho = U_D when rho*U_D < N, else 0.
+    # mask: 1 where rho*U_D < N (i.e., the min selects rho*U_D)
+    mask_rho = (rho_U_D < N_b) * 1.0                  # (B, M), 1 or 0
+
+    # ∂U_N/∂rho = U_D * mask_rho
+    dUN_drho = U_D * mask_rho                          # (B, M)
+
+    # ∂eff_N/∂U_N via chain rule (U_N appears in eff_N, R_N):
+    # eff_N = U_N * (1 + tau_N * (1 - exp(-R_N/tau_N)))
+    # R_N = max(N/U_N - 1, 0)
+    # ∂R_N/∂U_N = -N/U_N^2 when R_N > 0, else 0
+    mask_RN = (R_N_raw > 0.0) * 1.0                   # (B, M)
+    dRN_dUN = -N_b / (U_N ** 2) * mask_RN             # (B, M)
+
+    # ∂eff_N/∂U_N (direct, holding R_N constant):
+    # = 1 + tau_N*(1 - exp_RN)
+    deffN_dUN_direct = 1.0 + tau_N_b * (1.0 - exp_RN)  # (B, M)
+
+    # ∂eff_N/∂R_N = tau_N * U_N * (R_N/tau_N derivative of (1-exp(-R_N/tau_N)))
+    # = tau_N * U_N * (1/tau_N)*exp(-R_N/tau_N) = U_N * exp_RN
+    deffN_dRN = U_N * exp_RN                           # (B, M)
+
+    # total ∂eff_N/∂U_N = deffN_dUN_direct + deffN_dRN * dRN_dUN
+    deffN_dUN_total = deffN_dUN_direct + deffN_dRN * dRN_dUN  # (B, M)
+
+    d_rho = dpred_deffN * deffN_dUN_total * dUN_drho * mask_eff_N
+
+    # order: [A, tau_N, B, tau_D, alpha, C, rho]
+    jac = ops.stack([d_A, d_tau_N, d_B, d_tau_D, d_alpha, d_C, d_rho], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 4:
+#   L0 + A * M_n^(-a) + B * T_eff_n^(-b)
+# where
+#   M_n = max(M / _M_REF, _EPS)
+#   T_n = max(T / _T_REF, _EPS)
+#   U_n = max(U / _U_REF, _EPS)
+#   q = T_n / max(s * U_n * M_n^d, _EPS)
+#   T_eff_n = T_n / (1 + q)
+#
+# theta: [L0, A, a, B, b, s, d]
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    # X: (M, 3)
+    U, M, T = X[:, 0], X[:, 1], X[:, 2]
+
+    # theta: (B, 7)
+    L0 = theta[:, 0]
+    A = theta[:, 1]
+    a = theta[:, 2]
+    Bcoef = theta[:, 3]
+    b = theta[:, 4]
+    s = theta[:, 5]
+    d = theta[:, 6]
+
+    U_b = U[None, :]
+    M_b = M[None, :]
+    T_b = T[None, :]
+
+    M_n = ops.clamp_min(M_b / _M_REF, _EPS)
+    T_n = ops.clamp_min(T_b / _T_REF, _EPS)
+    U_n = ops.clamp_min(U_b / _U_REF, _EPS)
+
+    log_M_n = xp.log(ops.clamp_min(M_n, _EPS))
+
+    scale = s[:, None] * U_n * (M_n ** d[:, None])     # (B, M)
+    scale = ops.clamp_min(scale, _EPS)
+
+    q_val = T_n / scale                                 # (B, M)
+    denom = 1.0 + q_val                                 # (B, M)
+    T_eff_n = T_n / denom                               # (B, M)
+    T_eff_n = ops.clamp_min(T_eff_n, _EPS)
+
+    log_T_eff_n = xp.log(ops.clamp_min(T_eff_n, _EPS))
+
+    Mn_neg_a = M_n ** (-a[:, None])                     # (B, M)
+    Teff_neg_b = T_eff_n ** (-b[:, None])               # (B, M)
+
+    termM = A[:, None] * Mn_neg_a                       # (B, M)
+    termT = Bcoef[:, None] * Teff_neg_b                 # (B, M)
+
+    pred = L0[:, None] + termM + termT
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    # ∂/∂L0 = 1
+    d_L0 = ones
+
+    # ∂/∂A = M_n^(-a)
+    d_A = Mn_neg_a
+
+    # ∂/∂a = -termM * log(M_n)
+    d_a = -termM * log_M_n
+
+    # ∂/∂B = T_eff_n^(-b)
+    d_B = Teff_neg_b
+
+    # ∂/∂b = -termT * log(T_eff_n)
+    d_b = -termT * log_T_eff_n
+
+    # For s, d: need ∂pred/∂T_eff_n * ∂T_eff_n/∂(s or d)
+    # ∂pred/∂T_eff_n = -b * B * T_eff_n^(-b-1) = -b * termT / T_eff_n
+    dpred_dTeff = -b[:, None] * termT / T_eff_n         # (B, M)
+
+    # T_eff_n = T_n / (1 + T_n/scale) = T_n * scale / (scale + T_n)
+    # ∂T_eff_n/∂scale = T_n * (scale + T_n - scale) / (scale + T_n)^2
+    #                 = T_n^2 / (scale + T_n)^2
+    # But scale + T_n = scale * denom, and T_eff_n = T_n / denom, so:
+    # T_n^2 / (scale * denom)^2 = (T_n/denom)^2 / scale^2 = ... let's do directly:
+    # ∂T_eff_n/∂scale = T_n^2 / (scale + T_n)^2
+    scale_plus_Tn = scale + T_n
+    dTeff_dscale = T_n ** 2 / (scale_plus_Tn ** 2)      # (B, M)
+
+    # scale = s * U_n * M_n^d
+    # ∂scale/∂s = U_n * M_n^d = scale / s[:, None]
+    dscale_ds = scale / s[:, None]                       # (B, M)
+
+    # ∂scale/∂d = s * U_n * M_n^d * log(M_n) = scale * log(M_n)
+    dscale_dd = scale * log_M_n                          # (B, M)
+
+    d_s = dpred_dTeff * dTeff_dscale * dscale_ds
+    d_d = dpred_dTeff * dTeff_dscale * dscale_dd
+
+    # order: [L0, A, a, B, b, s, d]
+    jac = ops.stack([d_L0, d_A, d_a, d_B, d_b, d_s, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+# Scaling law 5:
+#   L = A / N^alpha + B / D_eff^beta + E
+# where
+#   D_eff = U^gamma * D^(1 - gamma)
+#
+# theta: [A, alpha, B, beta, E, gamma]
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    # X: (M, 3)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+
+    # theta: (B, 6)
+    A = theta[:, 0]
+    alpha = theta[:, 1]
+    Bcoef = theta[:, 2]
+    beta = theta[:, 3]
+    E = theta[:, 4]
+    gamma = theta[:, 5]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+
+    log_U = xp.log(ops.clamp_min(U_b, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+
+    D_eff = (U_b ** gamma[:, None]) * (D_b ** (1.0 - gamma[:, None]))
+    D_eff = ops.clamp_min(D_eff, _EPS)
+
+    log_D_eff = xp.log(ops.clamp_min(D_eff, _EPS))
+
+    N_neg_alpha = N_b ** (-alpha[:, None])               # (B, M)
+    D_eff_neg_beta = D_eff ** (-beta[:, None])           # (B, M)
+
+    termN = A[:, None] * N_neg_alpha
+    termD = Bcoef[:, None] * D_eff_neg_beta
+
+    pred = termN + termD + E[:, None]
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    # ∂/∂A = N^(-alpha)
+    d_A = N_neg_alpha
+
+    # ∂/∂alpha = -termN * log(N)
+    d_alpha = -termN * log_N
+
+    # ∂/∂B = D_eff^(-beta)
+    d_B = D_eff_neg_beta
+
+    # ∂/∂beta = -termD * log(D_eff)
+    d_beta = -termD * log_D_eff
+
+    # ∂/∂E = 1
+    d_E = ones
+
+    # ∂/∂gamma: D_eff = U^gamma * D^(1-gamma)
+    # log(D_eff) = gamma*log(U) + (1-gamma)*log(D)
+    # ∂log(D_eff)/∂gamma = log(U) - log(D) = log(U/D)
+    # ∂D_eff/∂gamma = D_eff * (log(U) - log(D))
+    # ∂pred/∂gamma = ∂pred/∂D_eff * ∂D_eff/∂gamma
+    # ∂pred/∂D_eff = -beta * B * D_eff^(-beta-1) = -beta * termD / D_eff
+    dpred_dDeff = -beta[:, None] * termD / D_eff
+    dDeff_dgamma = D_eff * (log_U - log_D)
+    d_gamma = dpred_dDeff * dDeff_dgamma
+
+    # order: [A, alpha, B, beta, E, gamma]
+    jac = ops.stack([d_A, d_alpha, d_B, d_beta, d_E, d_gamma], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+# Scaling law 6 (8p): Chinchilla + repeat-penalty factor
+#   R = D / U;  factor = 1 + C * max(R - 1, 0)^c * N^d
+#   D_eff = D / factor
+#   loss = E + A * N^(-alpha) + B * D_eff^(-beta)
+# theta: [E, A, alpha, B, beta, C, c, d]
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+    Ep = theta[:, 0]
+    A = theta[:, 1]
+    alpha = theta[:, 2]
+    Bcoef = theta[:, 3]
+    beta = theta[:, 4]
+    Cc = theta[:, 5]
+    c = theta[:, 6]
+    d = theta[:, 7]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+
+    R = D_b / U_b                                     # (1, M)
+    repeat_excess = ops.clamp_min(R - 1.0, 0.0)       # (1, M)
+    log_re = xp.log(ops.clamp_min(repeat_excess, _EPS))
+
+    re_c = repeat_excess ** c[:, None]                 # (B, M)
+    N_d = N_b ** d[:, None]                            # (B, M)
+    penalty = Cc[:, None] * re_c * N_d                 # (B, M)
+    factor = 1.0 + penalty                             # (B, M)
+    factor_safe = ops.clamp_min(factor, _EPS)
+
+    D_eff = D_b / factor_safe                          # (B, M)
+    D_eff = ops.clamp_min(D_eff, _EPS)
+
+    log_D_eff = xp.log(ops.clamp_min(D_eff, _EPS))
+
+    N_neg_alpha = N_b ** (-alpha[:, None])             # (B, M)
+    D_eff_neg_beta = D_eff ** (-beta[:, None])         # (B, M)
+
+    termN = A[:, None] * N_neg_alpha                   # (B, M)
+    termD = Bcoef[:, None] * D_eff_neg_beta            # (B, M)
+
+    pred = Ep[:, None] + termN + termD
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    # ∂/∂E = 1
+    d_E = ones
+
+    # ∂/∂A = N^(-alpha)
+    d_A = N_neg_alpha
+
+    # ∂/∂alpha = -termN * log(N)
+    d_alpha = -termN * log_N
+
+    # ∂/∂B = D_eff^(-beta)
+    d_B = D_eff_neg_beta
+
+    # ∂/∂beta = -termD * log(D_eff)
+    d_beta = -termD * log_D_eff
+
+    # For C, c, d: need ∂pred/∂D_eff * ∂D_eff/∂factor * ∂factor/∂param
+    # ∂pred/∂D_eff = -beta * B * D_eff^(-beta-1) = -beta * termD / D_eff
+    dpred_dDeff = -beta[:, None] * termD / D_eff       # (B, M)
+
+    # D_eff = D / factor  =>  ∂D_eff/∂factor = -D / factor^2 = -D_eff / factor
+    dDeff_dfactor = -D_eff / factor_safe               # (B, M)
+
+    dpred_dfactor = dpred_dDeff * dDeff_dfactor        # (B, M)
+
+    # factor = 1 + C * re^c * N^d
+    # ∂factor/∂C = re^c * N^d = penalty / Cc[:, None]
+    # But Cc could be 0, so compute directly:
+    dfactor_dC = re_c * N_d                            # (B, M)
+
+    # ∂factor/∂c = C * re^c * log(re) * N^d = penalty * log(re)
+    dfactor_dc = penalty * log_re                      # (B, M)
+
+    # ∂factor/∂d = C * re^c * N^d * log(N) = penalty * log(N)
+    dfactor_dd = penalty * log_N                       # (B, M)
+
+    d_Cc = dpred_dfactor * dfactor_dC
+    d_c = dpred_dfactor * dfactor_dc
+    d_d = dpred_dfactor * dfactor_dd
+
+    # order: [E, A, alpha, B, beta, C, c, d]
+    jac = ops.stack([d_E, d_A, d_alpha, d_B, d_beta, d_Cc, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 7 (7p): Multiplicative (N*U) product + additive terms
+#   loss = L0 + A * (N * U)^alpha_pu + B * D^alpha_t + C * N^alpha_p
+# theta: [L0, A, alpha_pu, B, alpha_t, C, alpha_p]
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+    L0 = theta[:, 0]
+    A = theta[:, 1]
+    alpha_pu = theta[:, 2]
+    Bcoef = theta[:, 3]
+    alpha_t = theta[:, 4]
+    Cc = theta[:, 5]
+    alpha_p = theta[:, 6]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+    NU = ops.clamp_min(N_b * U_b, _EPS)
+
+    log_NU = xp.log(ops.clamp_min(NU, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+
+    NU_apu = NU ** alpha_pu[:, None]                   # (B, M)
+    D_at = D_b ** alpha_t[:, None]                     # (B, M)
+    N_ap = N_b ** alpha_p[:, None]                     # (B, M)
+
+    term2 = A[:, None] * NU_apu
+    term3 = Bcoef[:, None] * D_at
+    term4 = Cc[:, None] * N_ap
+
+    pred = L0[:, None] + term2 + term3 + term4
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    d_L0 = ones
+    d_A = NU_apu
+    d_alpha_pu = term2 * log_NU
+    d_B = D_at
+    d_alpha_t = term3 * log_D
+    d_C = N_ap
+    d_alpha_p = term4 * log_N
+
+    # order: [L0, A, alpha_pu, B, alpha_t, C, alpha_p]
+    jac = ops.stack([d_L0, d_A, d_alpha_pu, d_B, d_alpha_t, d_C, d_alpha_p], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 8 (7p): Log-ratio vocabulary saturation
+#   vocab_ratio = log(U / D + 1)
+#   loss = a + b / D^alpha + c / N^beta + d * |vocab_ratio|^gamma
+# theta: [a, b, c, d, alpha, beta, gamma]
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+    a0 = theta[:, 0]
+    b0 = theta[:, 1]
+    c0 = theta[:, 2]
+    d0 = theta[:, 3]
+    alpha = theta[:, 4]
+    beta = theta[:, 5]
+    gamma = theta[:, 6]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+
+    D_neg_alpha = D_b ** (-alpha[:, None])             # (B, M)
+    N_neg_beta = N_b ** (-beta[:, None])               # (B, M)
+
+    termD = b0[:, None] * D_neg_alpha                  # b/D^alpha
+    termN = c0[:, None] * N_neg_beta                   # c/N^beta
+
+    vocab_ratio = xp.log(U_b / D_b + 1.0)             # (1, M) or (B, M)
+    abs_vr = ops.clamp_min(xp.abs(vocab_ratio) if hasattr(xp, 'abs') else ops.maximum(vocab_ratio, -vocab_ratio), _EPS)
+    log_abs_vr = xp.log(ops.clamp_min(abs_vr, _EPS))
+
+    abs_vr_gamma = abs_vr ** gamma[:, None]            # (B, M)
+    termV = d0[:, None] * abs_vr_gamma                 # d*|vr|^gamma
+
+    pred = a0[:, None] + termD + termN + termV
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    d_a = ones
+    d_b = D_neg_alpha                                  # ∂/∂b = 1/D^alpha
+    d_c = N_neg_beta                                   # ∂/∂c = 1/N^beta
+    d_d = abs_vr_gamma                                 # ∂/∂d = |vr|^gamma
+    d_alpha = -termD * log_D                           # ∂/∂alpha = -b*D^(-alpha)*log(D)
+    d_beta = -termN * log_N                            # ∂/∂beta = -c*N^(-beta)*log(N)
+    d_gamma = termV * log_abs_vr                       # ∂/∂gamma = d*|vr|^gamma*log(|vr|)
+
+    # order: [a, b, c, d, alpha, beta, gamma]
+    jac = ops.stack([d_a, d_b, d_c, d_d, d_alpha, d_beta, d_gamma], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 9 (7p): Multiplicative data-quality modulation
+#   loss = A / N^alpha + B / D^beta * (1 + C / U^gamma) + L_inf
+# theta: [A, alpha, B, beta, C, gamma, L_inf]
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+    A = theta[:, 0]
+    alpha = theta[:, 1]
+    Bcoef = theta[:, 2]
+    beta = theta[:, 3]
+    Cc = theta[:, 4]
+    gamma = theta[:, 5]
+    L_inf = theta[:, 6]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+    log_U = xp.log(ops.clamp_min(U_b, _EPS))
+
+    N_neg_alpha = N_b ** (-alpha[:, None])             # (B, M)
+    D_neg_beta = D_b ** (-beta[:, None])               # (B, M)
+    U_neg_gamma = U_b ** (-gamma[:, None])             # (B, M)
+
+    termN = A[:, None] * N_neg_alpha                   # A/N^alpha
+    quality = 1.0 + Cc[:, None] * U_neg_gamma          # 1 + C/U^gamma
+    data_base = Bcoef[:, None] * D_neg_beta            # B/D^beta
+    data_term = data_base * quality                    # B/D^beta * (1 + C/U^gamma)
+
+    pred = termN + data_term + L_inf[:, None]
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    # ∂/∂A = N^(-alpha)
+    d_A = N_neg_alpha
+
+    # ∂/∂alpha = -termN * log(N)
+    d_alpha = -termN * log_N
+
+    # ∂/∂B = D^(-beta) * quality
+    d_B = D_neg_beta * quality
+
+    # ∂/∂beta = -data_term * log(D)
+    d_beta = -data_term * log_D
+
+    # ∂/∂C = B/D^beta * U^(-gamma) = data_base * U^(-gamma)
+    d_C = data_base * U_neg_gamma
+
+    # ∂/∂gamma = B/D^beta * C * (-U^(-gamma)) * log(U)
+    #          = -data_base * C * U^(-gamma) * log(U)
+    d_gamma = -data_base * Cc[:, None] * U_neg_gamma * log_U
+
+    # ∂/∂L_inf = 1
+    d_Linf = ones
+
+    # order: [A, alpha, B, beta, C, gamma, L_inf]
+    jac = ops.stack([d_A, d_alpha, d_B, d_beta, d_C, d_gamma, d_Linf], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 10 (7p): Generalized mean (Lq-norm) data term
+#   loss = L0 + A * N^(-a) + B * (D^(-b*q) + (k*U)^(-b*q))^(1/q)
+# theta: [L0, A, B, a, b, k, q]
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    U, N, D = X[:, 0], X[:, 1], X[:, 2]
+    L0 = theta[:, 0]
+    A = theta[:, 1]
+    Bcoef = theta[:, 2]
+    a = theta[:, 3]
+    b = theta[:, 4]
+    k = theta[:, 5]
+    q = theta[:, 6]
+
+    U_b = ops.clamp_min(U[None, :], _EPS)
+    N_b = ops.clamp_min(N[None, :], _EPS)
+    D_b = ops.clamp_min(D[None, :], _EPS)
+
+    log_N = xp.log(ops.clamp_min(N_b, _EPS))
+    log_D = xp.log(ops.clamp_min(D_b, _EPS))
+
+    q_safe = ops.clamp_min(q, _EPS)
+    bq = b[:, None] * q_safe[:, None]                 # (B, M-broadcast) -> (B, 1)
+
+    t_D = D_b ** (-bq)                                # (B, M)
+    kU = ops.clamp_min(k[:, None] * U_b, _EPS)        # (B, M)
+    log_kU = xp.log(ops.clamp_min(kU, _EPS))
+    t_U = kU ** (-bq)                                 # (B, M)
+
+    S = t_D + t_U                                     # (B, M)
+    S_safe = ops.clamp_min(S, _EPS)
+    log_S = xp.log(ops.clamp_min(S_safe, _EPS))
+
+    inv_q = 1.0 / q_safe[:, None]                     # (B, 1)
+    gm = S_safe ** inv_q                               # (B, M)
+
+    N_neg_a = N_b ** (-a[:, None])                     # (B, M)
+
+    termN = A[:, None] * N_neg_a                       # (B, M)
+    termG = Bcoef[:, None] * gm                        # (B, M)
+
+    pred = L0[:, None] + termN + termG
+
+    # --- Jacobian ---
+    ones = pred * 0.0 + 1.0
+
+    # ∂/∂L0 = 1
+    d_L0 = ones
+
+    # ∂/∂A = N^(-a)
+    d_A = N_neg_a
+
+    # ∂/∂B = gm
+    d_B = gm
+
+    # ∂/∂a = -termN * log(N)
+    d_a = -termN * log_N
+
+    # For b, k, q we need derivatives through gm = S^(1/q)
+    # Let's compute ∂gm/∂S first:
+    # gm = S^(1/q)  =>  ∂gm/∂S = (1/q) * S^(1/q - 1) = gm / (q * S)
+    dgm_dS = gm / (q_safe[:, None] * S_safe)          # (B, M)
+
+    # ∂S/∂b: S = D^(-bq) + (kU)^(-bq)
+    # t_D = D^(-bq), ∂t_D/∂b = -q * t_D * log(D)  (since ∂(-bq)/∂b = -q)
+    # t_U = (kU)^(-bq), ∂t_U/∂b = -q * t_U * log(kU)
+    dS_db = -q_safe[:, None] * (t_D * log_D + t_U * log_kU)  # (B, M)
+
+    # Also need ∂gm/∂b via the exponent: gm = S^(1/q), S depends on b
+    # ∂gm/∂b = dgm_dS * dS_db
+    dgm_db = dgm_dS * dS_db
+    d_b = Bcoef[:, None] * dgm_db                     # (B, M)
+
+    # ∂S/∂k: t_U = (kU)^(-bq)
+    # ∂t_U/∂k = -bq * (kU)^(-bq-1) * U = -bq * t_U / (kU) * U = -bq * t_U / k[:, None]
+    # (since kU = k*U, ∂(kU)/∂k = U, and ∂t_U/∂(kU) = -bq * (kU)^(-bq-1))
+    dS_dk = -bq * t_U / k[:, None]                    # (B, M)
+    dgm_dk = dgm_dS * dS_dk
+    d_k = Bcoef[:, None] * dgm_dk                     # (B, M)
+
+    # ∂gm/∂q: gm = S^(1/q), where both S and the exponent 1/q depend on q.
+    # Use: log(gm) = (1/q) * log(S)
+    # ∂log(gm)/∂q = ∂(1/q)/∂q * log(S) + (1/q) * ∂log(S)/∂q
+    #             = (-1/q^2) * log(S) + (1/q) * (1/S) * ∂S/∂q
+    # ∂gm/∂q = gm * [(-1/q^2)*log(S) + (1/(q*S))*∂S/∂q]
+    #
+    # ∂S/∂q: t_D = D^(-bq) => ∂t_D/∂q = -b * t_D * log(D)
+    #         t_U = (kU)^(-bq) => ∂t_U/∂q = -b * t_U * log(kU)
+    dS_dq = -b[:, None] * (t_D * log_D + t_U * log_kU)  # (B, M)
+
+    q2 = q_safe[:, None] ** 2
+    dgm_dq = gm * (-log_S / q2 + dS_dq / (q_safe[:, None] * S_safe))
+    d_q = Bcoef[:, None] * dgm_dq                     # (B, M)
+
+    # order: [L0, A, B, a, b, k, q]
+    jac = ops.stack([d_L0, d_A, d_B, d_a, d_b, d_k, d_q], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+PARAM_BOUNDS = {
+    # Dataset: U (unique_tokens) ~ 1e8–2e11, N (params) ~ 7e6–9e9,
+    #          D (tokens) ~ 1e8–9e11, Loss ~ 2.3–8.1
+    #
+    # Bound derivation:
+    #   - Decay exponents (alpha, beta, etc.): (0.05, 2.0) — physically positive,
+    #     upper limit avoids numerically useless landscape regions.
+    #   - Mixed/signed exponents (gamma, delta, alpha_pu, …): tight range around
+    #     observed optimal, typically (-2, 0.5) for negative-decay parameters.
+    #   - Coefficients for N-decay terms A/N^alpha:
+    #       A_max ≈ L_max * N_min^alpha_max = 8 * (7e6)^2 ≈ 4e14 → use 1e9 with
+    #       alpha restricted to ≤ 2 (optimizer stays near typical alpha ≈ 0.3–1.0).
+    #   - Loss-floor constants: (-3, 10) — loss ∈ [2.3, 8.1], floor < total loss.
+    #   - Structural params (tau, rho, s, k, q): derived from data ratios / physics.
+    #
+    # Overflow: all float64-safe; exp(-R/tau) underflows to 0 (never NaN);
+    # power terms at extreme bounds are O(1e50) at worst, well below 1e308.
+
+    # sl_1: [A, alpha, B, beta, E, gamma, delta]
+    # A/N^alpha + B/D^beta + E*(U^gamma * N^delta)
+    # Optimal approx: A~5e5 (alpha~0.82), B~1e5 (beta~0.56), E~12, gamma~-0.04, delta~-0.03
+    # E*U^gamma*N^delta is a small "repeat-floor" term; restrict |gamma|,|delta|<=0.5
+    # so the floor stays O(1–100) and E doesn't need astronomically large values.
+    "sl_1": [(1e-3, 1e9), (0.05, 2.0), (1e-3, 1e8), (0.05, 2.0),
+             (-100, 200), (-0.5, 0.5), (-0.5, 0.5)],
+
+    # sl_2: [a, b, c, d, p, q, r]
+    # a + b*U^p + c*N^q + d*D^r
+    # Optimal approx: a~2, b~17–700, c~3400–5300, d~1e5, p~-0.14 to -0.38,
+    #   q~-0.48 to -0.51, r~-0.56 to -0.57
+    # Coefficients: b*U^p ~ O(1) at U~1e9, p~-0.4 → b ~ 3/U^(-0.4) ~ 3e4 max;
+    #   similarly c ~ 3e5, d ~ 1e6. Use 10x margin.
+    "sl_2": [(-3, 10), (-1e6, 1e6), (-1e6, 1e6), (-1e7, 1e7),
+             (-1.5, 0.5), (-1.5, 0.5), (-1.5, 0.5)],
+
+    # sl_3: [A, tau_N, B, tau_D, alpha, C, rho]
+    # Muennighoff data-constrained formula with effective N/D via exponential saturation.
+    # Optimal approx: A~2345, tau_N~0.07, B~14500, tau_D~31, alpha~0.45, C~2.3, rho~0.82
+    # tau: dimensionless repeat counts; tau_N can be very small (<<1) or up to O(100).
+    # rho: fraction U/N at crossover; rho*U_D is compared to N, range from 0.001 to 100.
+    "sl_3": [(1e-3, 1e7), (1e-3, 500), (1e-3, 1e7), (1e-3, 500),
+             (0.05, 2.0), (-3, 10), (1e-3, 100)],
+
+    # sl_4: [L0, A, a, B, b, s, d]
+    # L0 + A*M_n^(-a) + B*T_eff_n^(-b), T_eff_n = T_n/(1+T_n/(s*U_n*M_n^d))
+    # _M_REF=_T_REF=_U_REF=1 so M_n=N~7e6–9e9, T_n=D~1e8–9e11, U_n=U~1e8–2e11.
+    # Optimal approx: L0~2.5, A~4e6 (a~0.92), B~12500 (b~0.44), s~197, d~-0.13
+    # s*U_n*M_n^d ~ D at crossover; s ~ D/(U*N^d) ~ 1e10/(4e9*(2.5e8)^(-0.13)) ~ 200.
+    "sl_4": [(-3, 8), (1e-3, 1e11), (0.05, 2.5), (1e-3, 1e9),
+             (0.05, 2.5), (1e-5, 1e7), (-2.0, 1.5)],
+
+    # sl_5: [A, alpha, B, beta, E, gamma]
+    # A/N^alpha + B/D_eff^beta + E, D_eff = U^gamma * D^(1-gamma)
+    # gamma in [0,1]: D_eff is a geometric mean of U and D (U^gamma*D^(1-gamma)).
+    # Optimal approx: A~173 (alpha~0.28), B~1.7e6 (beta~0.71), E~2.3, gamma~0.34
+    # D_eff at gamma=0.34: D_eff ~ (4e9)^0.34*(1e10)^0.66 ~ 7e9; B/D_eff^0.71 ~ O(1).
+    "sl_5": [(1e-3, 1e10), (0.05, 2.0), (1e-3, 1e10), (0.05, 2.0),
+             (-3, 10), (0.0, 1.0)],
+
+    # sl_6: [E, A, alpha, B, beta, C, c, d]
+    # E + A*N^(-alpha) + B*D_eff^(-beta),
+    # D_eff = D / max(1 + C*(max(D/U-1,0))^c * N^d, eps)
+    # Optimal approx: E~3, A~1.6e6 (alpha~0.86), B~7e8 (beta~1.04), C~0.3, c~0.83, d~0.02
+    # D/U-1 ranges 0–8999; factor = 1+C*(8999)^c*N^d; with C=0.3,c=0.83,d=0.02 → factor~700.
+    # C>=0 (repeat penalty must increase factor); c in [0,2]; d in [-1,1].
+    "sl_6": [(-3, 10), (1e-3, 1e11), (0.05, 2.0), (1e-3, 1e12),
+             (0.05, 2.0), (0, 1e4), (0, 2.0), (-1.0, 1.0)],
+
+    # sl_7: [L0, A, alpha_pu, B, alpha_t, C, alpha_p]
+    # L0 + A*(N*U)^alpha_pu + B*D^alpha_t + C*N^alpha_p
+    # N*U range: ~7e14–1.5e21; exponents alpha_pu, alpha_t, alpha_p are negative (decay).
+    # Optimal approx: L0~2.4, A~1100 (alpha_pu~-0.18), B~95000 (alpha_t~-0.55),
+    #   C~7e11 (alpha_p~-1.77, nearly zero contribution at typical N).
+    "sl_7": [(-3, 10), (1e-3, 1e9), (-2.0, 0.5), (1e-3, 1e9),
+             (-2.0, 0.5), (-1e13, 1e13), (-2.5, 0.5)],
+
+    # sl_8: [a, b, c, d, alpha, beta, gamma]
+    # a + b/D^alpha + c/N^beta + d*|log(U/D+1)|^gamma
+    # vocab_ratio = log(U/D+1) in [0, ~7.5] over this dataset.
+    # WARNING: as gamma->0, |vr|^gamma->1, making a and d unidentifiable (a+d = const).
+    #   Restrict gamma >= 0.05 to reduce degeneracy; fix a in (-3, 10).
+    # Optimal approx (non-degenerate): a~3.5–3.9, b~8000–9600, c~6400–9000,
+    #   d~-1.7, alpha~0.42, beta~0.54, gamma~0.1–0.4.
+    "sl_8": [(-3, 10), (-1e8, 1e8), (-1e8, 1e8), (-200, 200),
+             (0.05, 2.0), (0.05, 2.0), (0.05, 5.0)],
+
+    # sl_9: [A, alpha, B, beta, C, gamma, L_inf]
+    # A/N^alpha + B/D^beta * (1 + C/U^gamma) + L_inf
+    # Optimal approx: A~90 (alpha~0.22), B~16000 (beta~0.47),
+    #   C~1.1e9 (gamma~1.20), L_inf~2.0
+    # C/U^gamma at U_typ=4e9, gamma=1.2: C/(4e9)^1.2 ~ 1.1e9/2.4e10 ~ 0.046 (small factor).
+    # C can be large because U is also large; allow up to 1e11.
+    "sl_9": [(1e-3, 1e7), (0.05, 2.0), (1e-3, 1e7), (0.05, 2.0),
+             (0, 1e11), (0.05, 2.0), (-3, 10)],
+
+    # sl_10: [L0, A, B, a, b, k, q]
+    # L0 + A*N^(-a) + B*(D^(-b*q) + (k*U)^(-b*q))^(1/q)
+    # q: generalized-mean exponent; k: scales U to match D in the Lq-norm.
+    # Optimal approx: L0~2.3, A~14500 (a~0.63), B~1900 (b~0.37), k~23, q~12–16.
+    # k*U_typ=23*4e9=9e10 ~ D_typ=1e10 (same order, reasonable crossover).
+    # q can be large (O(10–20)) meaning the law approaches a hard min over D and k*U.
+    "sl_10": [(-3, 8), (1e-3, 1e9), (1e-3, 1e9), (0.05, 2.0),
+              (0.05, 2.0), (1e-3, 1e4), (0.1, 50.0)],
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 7, "sl_2": 7, "sl_3": 7, "sl_4": 7, "sl_5": 6,
+    "sl_6": 8, "sl_7": 7, "sl_8": 7, "sl_9": 7, "sl_10": 7,
+}

data_constrained_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acdc55ff3bffb3020b365007d2b18bc0bf0ec3e359b2ceb3e09abe2bbb94cc2e
+size 2736

data_constrained_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0e6f059e657c7476f8f2636110e391d086c78bd826a50c4cc62f06e73c7b020
+size 4589

domain_mixture_scaling_law/laws.py

@@ -0,0 +1,654 @@
+"""Scaling laws for domain mixture proportions (multi-output).
+
+X columns: [proportion_domain_1..5]
+Output: [loss_domain_1..5]
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+_NUM_DOMAINS = 5
+
+
+def _squeeze(pred, jac, B):
+    if B == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+def _assign(arr, backend, idx, val):
+    """Assign val to arr at index idx, handling jax immutability."""
+    if backend == "jax":
+        return arr.at[idx].set(val)
+    arr[idx] = val
+    return arr
+
+
+# sl_1 (30p): loss_i = a_i + b_i*log(p_i+eps) + sum_{j!=i} c_{ij}*p_j
+# Per domain: a_i(1) + b_i(1) + c_{ij}(4) = 6 -> 30 total
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 30
+    if backend == "torch":
+        out = xp.zeros((B, M, _NUM_DOMAINS), dtype=xp.float64)
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P), dtype=xp.float64)
+    else:
+        out = xp.zeros((B, M, _NUM_DOMAINS))
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        a_i = theta[:, offset]
+        b_i = theta[:, offset + 1]
+        c_ij = theta[:, offset + 2: offset + 6]
+        p_i = ops.clamp_min(X[:, i], _EPS)
+        log_pi = xp.log(p_i)  # (M,)
+        val = a_i[:, None] + b_i[:, None] * log_pi[None, :]
+        j_indices = [j for j in range(_NUM_DOMAINS) if j != i]
+        for k, j in enumerate(j_indices):
+            val = val + c_ij[:, k:k+1] * X[None, :, j]
+        out = _assign(out, backend, (slice(None), slice(None), i), val)
+        # Jacobian
+        # d/d a_i = 1
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset), ones_BM)
+        # d/d b_i = log(p_i)
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 1),
+                       log_pi[None, :] * ones_BM)
+        # d/d c_ij = p_j
+        for k, j in enumerate(j_indices):
+            jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 2 + k),
+                           X[None, :, j] * ones_BM)
+        offset += 6
+    return _squeeze(out, jac, B)
+
+
+# sl_2 (35p): loss_i = A_i*(p_i+eps_i)^(-alpha_i)*exp(sum_j w_{ij}*p_j)
+# Per domain: A(1)+eps(1)+alpha(1)+w(4 cross)=7 -> 35 total
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 35
+    if backend == "torch":
+        out = xp.zeros((B, M, _NUM_DOMAINS), dtype=xp.float64)
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P), dtype=xp.float64)
+    else:
+        out = xp.zeros((B, M, _NUM_DOMAINS))
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P))
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        A_i = theta[:, offset]
+        eps_i = theta[:, offset + 1]
+        alpha_i = theta[:, offset + 2]
+        w_ij = theta[:, offset + 3: offset + 7]
+        p_i = ops.clamp_min(X[:, i] + eps_i[:, None], _EPS)  # (B, M)
+        power_term = A_i[:, None] * (p_i ** (-alpha_i[:, None]))  # (B, M)
+        j_indices = [j for j in range(_NUM_DOMAINS) if j != i]
+        interaction = xp.zeros((B, M)) if backend != "torch" else xp.zeros((B, M), dtype=xp.float64)
+        for k, j in enumerate(j_indices):
+            interaction = interaction + w_ij[:, k:k+1] * X[None, :, j]
+        interaction = ops.clamp(interaction, min=-20.0, max=20.0)
+        exp_inter = ops.exp(interaction)  # (B, M)
+        val = power_term * exp_inter  # (B, M)
+        out = _assign(out, backend, (slice(None), slice(None), i), val)
+
+        # Jacobian: val = A_i * (p_i+eps_i)^(-alpha_i) * exp(interaction)
+        # Let f = val
+        # d/d A_i = f / A_i = (p_i)^(-alpha_i) * exp(interaction)
+        d_A = val / ops.clamp_min(xp.abs(A_i[:, None]), _EPS)
+        # More robustly: d_A = (p_i ** (-alpha_i)) * exp_inter
+        d_A = (p_i ** (-alpha_i[:, None])) * exp_inter
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset), d_A)
+
+        # d/d eps_i: chain through p_i = X[:,i] + eps_i
+        # d(val)/d(eps_i) = A_i * (-alpha_i) * p_i^(-alpha_i - 1) * 1 * exp(inter)
+        #                  = val * (-alpha_i) / p_i
+        d_eps = val * (-alpha_i[:, None]) / p_i
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 1), d_eps)
+
+        # d/d alpha_i: d/d(alpha) of p_i^(-alpha) = -log(p_i) * p_i^(-alpha)
+        # d(val)/d(alpha_i) = A_i * (-log(p_i)) * p_i^(-alpha_i) * exp(inter)
+        #                   = val * (-log(p_i))
+        log_pi = xp.log(ops.clamp_min(p_i, _EPS))
+        d_alpha = val * (-log_pi)
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 2), d_alpha)
+
+        # d/d w_ij[k]: d(val)/d(w_k) = val * p_j  (from exp derivative)
+        for k, j in enumerate(j_indices):
+            d_w = val * X[None, :, j]
+            jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 3 + k), d_w)
+
+        offset += 7
+    return _squeeze(out, jac, B)
+
+
+# sl_3 (35p): loss_i = base_i + coeff_i*p_i^exp_i + sum_{j!=i} W_{ij}*p_j
+# Power law self + full linear cross (5 base + 5 coeff + 5 exp + 20 cross = 35)
+# Repack: per domain i: base(1)+coeff(1)+exp(1)+W_{ij}(4)=7 -> 35
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 35
+    if backend == "torch":
+        import torch
+        out = torch.zeros((B, M, _NUM_DOMAINS), dtype=torch.float64)
+        jac = torch.zeros((B, M, _NUM_DOMAINS, P), dtype=torch.float64)
+    else:
+        import numpy as np
+        out = np.zeros((B, M, _NUM_DOMAINS))
+        jac = np.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        base_i = theta[:, offset]
+        coeff_i = theta[:, offset + 1]
+        exp_i = theta[:, offset + 2]
+        W_ij = theta[:, offset + 3: offset + 7]
+        p_i = ops.clamp_min(X[:, i], _EPS)
+        p_i_pow = p_i[None, :] ** exp_i[:, None]  # (B, M)
+        val = base_i[:, None] + coeff_i[:, None] * p_i_pow
+        j_indices = [j for j in range(_NUM_DOMAINS) if j != i]
+        for k, j in enumerate(j_indices):
+            val = val + W_ij[:, k:k+1] * X[None, :, j]
+        out[:, :, i] = val
+
+        # Jacobian
+        # d/d base_i = 1
+        jac[:, :, i, offset] = ones_BM
+        # d/d coeff_i = p_i^exp_i
+        jac[:, :, i, offset + 1] = p_i_pow
+        # d/d exp_i = coeff_i * p_i^exp_i * log(p_i)
+        log_pi = xp.log(ops.clamp_min(p_i, _EPS))  # (M,)
+        jac[:, :, i, offset + 2] = coeff_i[:, None] * p_i_pow * log_pi[None, :]
+        # d/d W_ij[k] = p_j
+        for k, j in enumerate(j_indices):
+            jac[:, :, i, offset + 3 + k] = X[None, :, j] * ones_BM
+
+        offset += 7
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.array(out)
+        jac = jnp.array(jac)
+    return _squeeze(out, jac, B)
+
+
+# sl_4 (35p): loss_i = exp(sum_k C_{ik}*p_k^alpha_k + bias_i)
+# Exponential of linear combo of power-transformed props
+# 5 bias + 25 C + 5 alpha = 35
+# Pack: 5 alpha first, then per domain: bias(1)+C(5)=6 -> 5+30=35
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 35
+    # First 5 params: shared alpha exponents
+    alphas = theta[:, :5]  # (B, 5)
+    if backend == "torch":
+        out = xp.zeros((B, M, _NUM_DOMAINS), dtype=xp.float64)
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P), dtype=xp.float64)
+    else:
+        out = xp.zeros((B, M, _NUM_DOMAINS))
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P))
+
+    # Precompute p_k^alpha_k and log(p_k) for all k
+    p_pow = []   # list of (B, M) arrays: p_k^alpha_k
+    log_p = []   # list of (M,) arrays: log(p_k)
+    for k in range(_NUM_DOMAINS):
+        p_k = ops.clamp_min(X[:, k], _EPS)
+        lp_k = xp.log(ops.clamp_min(p_k, _EPS))
+        log_p.append(lp_k)
+        p_pow.append(p_k[None, :] ** alphas[:, k:k+1])  # (B, M)
+
+    offset = 5
+    for i in range(_NUM_DOMAINS):
+        bias_i = theta[:, offset]
+        C_ik = theta[:, offset + 1: offset + 6]  # (B, 5)
+        # sum_k C_ik * p_k^alpha_k
+        lin = bias_i[:, None]  # (B, 1) -> broadcast to (B, M)
+        for k in range(_NUM_DOMAINS):
+            lin = lin + C_ik[:, k:k+1] * p_pow[k]
+        lin = ops.clamp(lin, min=-50.0, max=50.0)
+        val = ops.exp(lin)  # (B, M)
+        out = _assign(out, backend, (slice(None), slice(None), i), val)
+
+        # Jacobian: val = exp(lin)
+        # d(val)/d(param) = val * d(lin)/d(param)
+
+        # d/d alpha_k (shared, index k in 0..4):
+        # d(lin)/d(alpha_k) = C_ik * p_k^alpha_k * log(p_k)
+        for k in range(_NUM_DOMAINS):
+            d_alpha_k = val * C_ik[:, k:k+1] * p_pow[k] * log_p[k][None, :]
+            # Accumulate into shared alpha slot (index k)
+            # Multiple domains contribute to same alpha_k, so we add
+            if backend == "jax":
+                jac = jac.at[:, :, i, k].set(d_alpha_k)
+            else:
+                jac[:, :, i, k] = d_alpha_k
+
+        # d/d bias_i = val * 1
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset), val)
+
+        # d/d C_ik = val * p_k^alpha_k
+        for k in range(_NUM_DOMAINS):
+            d_C = val * p_pow[k]
+            jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 1 + k), d_C)
+
+        offset += 6
+    return _squeeze(out, jac, B)
+
+
+# sl_5 (35p): loss_i = b_i + sum_j W_{ij} * p_j^alpha_j
+# Full weight matrix on power-transformed proportions (shared alpha)
+# 5 alpha + 5 bias + 25 W = 35
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 35
+    alphas = theta[:, :5]  # (B, 5)
+    if backend == "torch":
+        import torch
+        out = torch.zeros((B, M, _NUM_DOMAINS), dtype=torch.float64)
+        jac = torch.zeros((B, M, _NUM_DOMAINS, P), dtype=torch.float64)
+    else:
+        import numpy as np
+        out = np.zeros((B, M, _NUM_DOMAINS))
+        jac = np.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+
+    # Precompute p_j^alpha_j and log(p_j) for all j
+    p_pow = []
+    log_p = []
+    for j in range(_NUM_DOMAINS):
+        p_j = ops.clamp_min(X[:, j], _EPS)
+        lp_j = xp.log(ops.clamp_min(p_j, _EPS))
+        log_p.append(lp_j)
+        p_pow.append(p_j[None, :] ** alphas[:, j:j+1])  # (B, M)
+
+    offset = 5
+    for i in range(_NUM_DOMAINS):
+        b_i = theta[:, offset]
+        W_ij = theta[:, offset + 1: offset + 6]  # (B, 5)
+        val = b_i[:, None]
+        for j in range(_NUM_DOMAINS):
+            val = val + W_ij[:, j:j+1] * p_pow[j]
+        out[:, :, i] = val
+
+        # Jacobian
+        # d/d alpha_j (shared, index j in 0..4):
+        # d(val)/d(alpha_j) = W_ij * p_j^alpha_j * log(p_j)
+        for j in range(_NUM_DOMAINS):
+            d_alpha = W_ij[:, j:j+1] * p_pow[j] * log_p[j][None, :]
+            jac[:, :, i, j] = d_alpha
+
+        # d/d b_i = 1
+        jac[:, :, i, offset] = ones_BM
+
+        # d/d W_ij = p_j^alpha_j
+        for j in range(_NUM_DOMAINS):
+            jac[:, :, i, offset + 1 + j] = p_pow[j]
+
+        offset += 6
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.array(out)
+        jac = jnp.array(jac)
+    return _squeeze(out, jac, B)
+
+
+# sl_6 (35p): loss_i = C_i + A_i * (sum_j T_{ij}*p_j)^(-alpha_i)
+# Effective-mixture power law
+# Per domain: C(1)+A(1)+alpha(1)+T(4 cross)=7 -> 35
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 35
+    if backend == "torch":
+        import torch
+        out = torch.zeros((B, M, _NUM_DOMAINS), dtype=torch.float64)
+        jac = torch.zeros((B, M, _NUM_DOMAINS, P), dtype=torch.float64)
+    else:
+        import numpy as np
+        out = np.zeros((B, M, _NUM_DOMAINS))
+        jac = np.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        C_i = theta[:, offset]
+        A_i = theta[:, offset + 1]
+        alpha_i = theta[:, offset + 2]
+        T_ij = theta[:, offset + 3: offset + 7]  # 4 weights for j!=i
+        # eff = p_i + sum_{j!=i} T_ij * p_j
+        eff = X[None, :, i]  # (1, M) or (B, M) after broadcast
+        j_indices = [j for j in range(_NUM_DOMAINS) if j != i]
+        for k, j in enumerate(j_indices):
+            eff = eff + T_ij[:, k:k+1] * X[None, :, j]
+        eff = ops.clamp_min(eff, _EPS)  # (B, M)
+        eff_pow = eff ** (-alpha_i[:, None])  # (B, M)
+        val = C_i[:, None] + A_i[:, None] * eff_pow
+        out[:, :, i] = val
+
+        # Jacobian
+        # power_term = A_i * eff^(-alpha_i)
+        power_term = A_i[:, None] * eff_pow  # (B, M)
+        log_eff = xp.log(ops.clamp_min(eff, _EPS))
+
+        # d/d C_i = 1
+        jac[:, :, i, offset] = ones_BM
+        # d/d A_i = eff^(-alpha_i)
+        jac[:, :, i, offset + 1] = eff_pow
+        # d/d alpha_i = A_i * eff^(-alpha_i) * (-log(eff)) = power_term * (-log(eff))
+        jac[:, :, i, offset + 2] = power_term * (-log_eff)
+        # d/d T_ij[k] = A_i * (-alpha_i) * eff^(-alpha_i - 1) * p_j
+        #             = power_term * (-alpha_i) / eff * p_j
+        for k, j in enumerate(j_indices):
+            d_T = power_term * (-alpha_i[:, None]) / eff * X[None, :, j]
+            jac[:, :, i, offset + 3 + k] = d_T
+
+        offset += 7
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.array(out)
+        jac = jnp.array(jac)
+    return _squeeze(out, jac, B)
+
+
+# sl_7 (40p): loss_i = intercept_i + sum_j (c_lin_{ij}*p_j + c_log_{ij}*log(p_j+eps))
+# Simplest: per domain 8p total -> 40. Use: a_i + b_i*p_i + c_i*log(p_i) + sum_{j!=i}(d_{ij}*p_j + e_i*log(p_j))
+# Per domain: a(1)+b(1)+c(1)+d(4)+e(1)=8 -> 40
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 40
+    if backend == "torch":
+        out = xp.zeros((B, M, _NUM_DOMAINS), dtype=xp.float64)
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P), dtype=xp.float64)
+    else:
+        out = xp.zeros((B, M, _NUM_DOMAINS))
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        a_i = theta[:, offset]
+        b_i = theta[:, offset + 1]
+        c_i = theta[:, offset + 2]
+        d_ij = theta[:, offset + 3: offset + 7]  # 4 cross-domain linear
+        e_i = theta[:, offset + 7]  # shared cross-domain log coeff
+        p_i = ops.clamp_min(X[:, i], _EPS)
+        log_pi = xp.log(p_i)  # (M,)
+        val = a_i[:, None] + b_i[:, None] * X[None, :, i] + c_i[:, None] * log_pi[None, :]
+        j_indices = [j for j in range(_NUM_DOMAINS) if j != i]
+        # Accumulate sum of log(p_j) for d/d e_i
+        sum_log_pj = xp.zeros((M,)) if backend != "torch" else xp.zeros((M,), dtype=xp.float64)
+        for k, j in enumerate(j_indices):
+            p_j = ops.clamp_min(X[:, j], _EPS)
+            log_pj = xp.log(p_j)  # (M,)
+            val = val + d_ij[:, k:k+1] * X[None, :, j] + e_i[:, None] * log_pj[None, :]
+            sum_log_pj = sum_log_pj + log_pj
+        out = _assign(out, backend, (slice(None), slice(None), i), val)
+
+        # Jacobian
+        # d/d a_i = 1
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset), ones_BM)
+        # d/d b_i = p_i (the raw X value, not clamped -- actually it uses X[None,:,i])
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 1),
+                       X[None, :, i] * ones_BM)
+        # d/d c_i = log(p_i)
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 2),
+                       log_pi[None, :] * ones_BM)
+        # d/d d_ij[k] = p_j
+        for k, j in enumerate(j_indices):
+            jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 3 + k),
+                           X[None, :, j] * ones_BM)
+        # d/d e_i = sum_{j!=i} log(p_j)
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 7),
+                       sum_log_pj[None, :] * ones_BM)
+        offset += 8
+    return _squeeze(out, jac, B)
+
+
+# sl_8 (15p): loss_i = c_i - a_i * p_i^b_i
+# Single-domain power law (depends only on own proportion)
+# Per domain: 3p -> 15
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 15
+    if backend == "torch":
+        import torch
+        out = torch.zeros((B, M, _NUM_DOMAINS), dtype=torch.float64)
+        jac = torch.zeros((B, M, _NUM_DOMAINS, P), dtype=torch.float64)
+    else:
+        import numpy as np
+        out = np.zeros((B, M, _NUM_DOMAINS))
+        jac = np.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        c_i = theta[:, offset]
+        a_i = theta[:, offset + 1]
+        b_i = theta[:, offset + 2]
+        p_i = ops.clamp_min(X[:, i], _EPS)
+        log_pi = xp.log(ops.clamp_min(p_i, _EPS))  # (M,)
+        p_i_pow = p_i[None, :] ** b_i[:, None]  # (B, M)
+        val = c_i[:, None] - a_i[:, None] * p_i_pow
+        out[:, :, i] = val
+
+        # Jacobian
+        # d/d c_i = 1
+        jac[:, :, i, offset] = ones_BM
+        # d/d a_i = -p_i^b_i
+        jac[:, :, i, offset + 1] = -p_i_pow
+        # d/d b_i = -a_i * p_i^b_i * log(p_i)
+        jac[:, :, i, offset + 2] = -a_i[:, None] * p_i_pow * log_pi[None, :]
+
+        offset += 3
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.array(out)
+        jac = jnp.array(jac)
+    return _squeeze(out, jac, B)
+
+
+# sl_9 (15p): loss_i = a_i + b_i*log(p_i+eps) + c_i*[log(p_i+eps)]^2
+# Quadratic-in-log
+# Per domain: 3p -> 15
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 15
+    if backend == "torch":
+        out = xp.zeros((B, M, _NUM_DOMAINS), dtype=xp.float64)
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P), dtype=xp.float64)
+    else:
+        out = xp.zeros((B, M, _NUM_DOMAINS))
+        jac = xp.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        a_i = theta[:, offset]
+        b_i = theta[:, offset + 1]
+        c_i = theta[:, offset + 2]
+        p_i = ops.clamp_min(X[:, i], _EPS)
+        lp = xp.log(p_i)[None, :]  # (1, M)
+        val = a_i[:, None] + b_i[:, None] * lp + c_i[:, None] * lp ** 2
+        out = _assign(out, backend, (slice(None), slice(None), i), val)
+
+        # Jacobian
+        # d/d a_i = 1
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset), ones_BM)
+        # d/d b_i = log(p_i)
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 1),
+                       lp * ones_BM)
+        # d/d c_i = [log(p_i)]^2
+        jac = _assign(jac, backend, (slice(None), slice(None), i, offset + 2),
+                       (lp ** 2) * ones_BM)
+
+        offset += 3
+    return _squeeze(out, jac, B)
+
+
+# sl_10 (15p): loss_i = a_i + b_i / (p_i + eps_i)
+# Reciprocal law
+# Per domain: 3p -> 15
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    B, M = theta.shape[0], X.shape[0]
+    P = 15
+    if backend == "torch":
+        import torch
+        out = torch.zeros((B, M, _NUM_DOMAINS), dtype=torch.float64)
+        jac = torch.zeros((B, M, _NUM_DOMAINS, P), dtype=torch.float64)
+    else:
+        import numpy as np
+        out = np.zeros((B, M, _NUM_DOMAINS))
+        jac = np.zeros((B, M, _NUM_DOMAINS, P))
+    ones_BM = xp.ones((B, M)) if backend != "torch" else xp.ones((B, M), dtype=xp.float64)
+    offset = 0
+    for i in range(_NUM_DOMAINS):
+        a_i = theta[:, offset]
+        b_i = theta[:, offset + 1]
+        eps_i = theta[:, offset + 2]
+        denom = ops.clamp_min(X[None, :, i] + eps_i[:, None], _EPS)  # (B, M)
+        val = a_i[:, None] + b_i[:, None] / denom
+        out[:, :, i] = val
+
+        # Jacobian
+        # d/d a_i = 1
+        jac[:, :, i, offset] = ones_BM
+        # d/d b_i = 1 / (p_i + eps_i)
+        jac[:, :, i, offset + 1] = 1.0 / denom
+        # d/d eps_i = -b_i / (p_i + eps_i)^2
+        jac[:, :, i, offset + 2] = -b_i[:, None] / (denom ** 2)
+
+        offset += 3
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.array(out)
+        jac = jnp.array(jac)
+    return _squeeze(out, jac, B)
+
+
+PARAM_BOUNDS = {
+    # Dataset: p_i (proportions) in [0, 0.75], min nonzero ~0.03125,
+    #          log(p_i) in [-3.47, -0.29], loss_i in [1.21, 3.97] (per domain).
+    #
+    # Bound derivation:
+    #   - Loss-floor constants (a_i, base_i, C_i, c_i in sl_8): (-3, 6) —
+    #     total loss is 1.21–3.97, so floor < 4.
+    #   - Log coefficients (b_i, c_i in sl_1/7/9): loss / |log(p_min)| ~ 3/3.47 ~ 0.9,
+    #     so |coeff| ≲ 3–5; use (-10, 5) or (-5, 5) with margin.
+    #   - Linear cross-domain weights (c_ij, W_ij, d_ij): p_j ≤ 0.75, contribution
+    #     ≲ 3 → |weight| ≲ 4; use (-10, 10) with generous margin.
+    #   - Power-law exponents (exp_i, alpha_i, b_i in sl_8): typically 0–2 for physical
+    #     decay; allow (-2, 4) for exploration.
+    #   - Interaction / mixing weights (w_ij in sl_2, T_ij in sl_6): code already
+    #     clamps exp() to [-20,20]/[-50,50], so overflow is impossible; use (-5, 5).
+    #   - sl_2 A_i (scale): (0, 10) — (p+eps)^{-alpha} ~ 1–30, A * 30 ~ 3 → A ≲ 10.
+    #   - sl_4/5 shared alphas: (-1, 3) — fitted values 0.97–1.98.
+    #   - sl_8 c_i (maximum loss), a_i (decay scale), b_i (exponent): all positive,
+    #     fitted a_i ~ 0.23–0.84, b_i ~ 0.23–0.34, c_i ~ 1.96–3.59.
+    #   - sl_10 b_i: very small (~0.01–0.06 in fit); use (-1, 1).
+    #   - sl_10 eps_i: small shift; use (-0.03, 0.3).
+    #
+    # No overflow: all expressions bounded by construction or by code-level clamps.
+
+    # sl_1: 30p = 5 × [a_i, b_i, c_i1..c_i4]
+    # loss_i = a_i + b_i*log(p_i) + sum_{j≠i} c_ij*p_j
+    # Optimal: a~0.8–3.3, b~-0.02–0.003 (near zero), c~-0.5–1.6
+    # b_i·log(p_i): log(p) in [-3.47, -0.29]; for |b|·3.47 ≲ 3 → |b| ≲ 1. Use (-10, 5).
+    "sl_1": [(-3, 6), (-10, 5), (-10, 10), (-10, 10), (-10, 10), (-10, 10)] * 5,
+
+    # sl_2: 35p = 5 × [A_i, eps_i, alpha_i, w_i1..w_i4]
+    # loss_i = A_i*(p_i+eps_i)^{-alpha_i} * exp(sum_j w_ij*p_j)  [exp clamped ±20]
+    # Optimal: A~2.2–6.2, eps~0.027–0.091, alpha~0.05–0.46, w~-1.5–0.1
+    "sl_2": [(0, 10), (-0.03, 0.2), (0, 2), (-5, 5), (-5, 5), (-5, 5), (-5, 5)] * 5,
+
+    # sl_3: 35p = 5 × [base_i, coeff_i, exp_i, W_i1..W_i4]
+    # loss_i = base_i + coeff_i*p_i^exp_i + sum_{j≠i} W_ij*p_j
+    # Optimal: base~0–4.4, coeff~-11–7.2, exp~1.2–2.6, W~-1.6–3.8
+    # At exp_i=-2, p_min^{-2}=1024 → coeff·1024 ≲ 3 → coeff ≲ 0.003; tight with (-20,20).
+    "sl_3": [(-3, 6), (-20, 20), (-2, 4), (-10, 10), (-10, 10), (-10, 10), (-10, 10)] * 5,
+
+    # sl_4: 35p = 5 shared alphas + 5 × [bias_i, C_i1..C_i5]
+    # loss_i = exp(bias_i + sum_k C_ik*p_k^alpha_k)  [lin clamped to ±50]
+    # log(loss) in [0.19, 1.37]; so lin ~ 0.2–1.4; bias + sum ~ 0.2–1.4.
+    # Optimal: alphas~0.97–1.93, bias~-0.85–1.45, C~-3.95–4.08
+    "sl_4": [(-1, 3)] * 5 + [(-3, 3), (-10, 10), (-10, 10), (-10, 10), (-10, 10), (-10, 10)] * 5,
+
+    # sl_5: 35p = 5 shared alphas + 5 × [b_i, W_i1..W_i5]
+    # loss_i = b_i + sum_j W_ij*p_j^alpha_j
+    # Optimal: alphas~1.04–1.98, b~1.1–3.5, W~-15.5–7.5
+    # At alpha=2, p_min^2=0.001 → W·0.001 ≲ 3 → W ≲ 3000 (but optimal max |W|~15.5).
+    # Use (-25, 25) to contain observed -15.5 with margin.
+    "sl_5": [(-1, 3)] * 5 + [(-3, 6), (-25, 25), (-25, 25), (-25, 25), (-25, 25), (-25, 25)] * 5,
+
+    # sl_6: 35p = 5 × [C_i, A_i, alpha_i, T_i1..T_i4]
+    # loss_i = C_i + A_i*(p_i + sum_{j≠i} T_ij*p_j)^{-alpha_i}  [eff clamped ≥ EPS]
+    # Optimal: C~1.6–3.4, A~0–0.044 (near zero), alpha~0.22–1.83, T~-3.1–4.5
+    # A_i very small in fit (sl_6 mostly reduces to constant C); allow (0, 10).
+    "sl_6": [(-3, 6), (0, 10), (0, 3), (-5, 5), (-5, 5), (-5, 5), (-5, 5)] * 5,
+
+    # sl_7: 40p = 5 × [a_i, b_i, c_i, d_i1..d_i4, e_i]
+    # loss_i = a_i + b_i*p_i + c_i*log(p_i) + sum_{j≠i}(d_ij*p_j + e_i*log(p_j))
+    # Optimal: a~-2.8–2.8, b~-0.9–6.7, c~-0.02–0.01, d~-3.6–6.6, e~-0.007–0.008
+    # c_i and e_i are near-zero (log terms contribute little); use (-5, 5).
+    "sl_7": [(-5, 8), (-10, 15), (-5, 5), (-10, 10), (-10, 10), (-10, 10), (-10, 10), (-5, 5)] * 5,
+
+    # sl_8: 15p = 5 × [c_i, a_i, b_i]
+    # loss_i = c_i - a_i*p_i^{b_i}  (physical: a_i>0, b_i>0, c_i = max loss at p_i→0)
+    # Optimal: c~1.96–3.59, a~0.23–0.84, b~0.23–0.34
+    # At p_i=0.03125, b_i=1: a·0.03125 ≲ 2 → a ≲ 64; use (0, 5) as tight bound.
+    "sl_8": [(0, 6), (0, 5), (0, 3)] * 5,
+
+    # sl_9: 15p = 5 × [a_i, b_i, c_i]
+    # loss_i = a_i + b_i*log(p_i) + c_i*[log(p_i)]^2
+    # Optimal: a~1.17–3.25, b~-0.15 to -0.04, c~-0.004 to -0.001 (near zero)
+    # [log(p)]^2 in [0.08, 12]; c·12 ≲ 0.05 → negligible; use (-1, 1) for c_i.
+    "sl_9": [(-3, 6), (-2, 1), (-1, 1)] * 5,
+
+    # sl_10: 15p = 5 × [a_i, b_i, eps_i]
+    # loss_i = a_i + b_i / (p_i + eps_i)  [denom clamped ≥ EPS]
+    # Optimal: a~1.28–3.27, b~0.009–0.057, eps~0.014–0.100
+    # b_i very small: b/(p+eps) ~ 0.05/(0.25+0.05) ~ 0.17; use (-1, 1).
+    "sl_10": [(-3, 6), (-1, 1), (-0.03, 0.3)] * 5,
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 30, "sl_2": 35, "sl_3": 35, "sl_4": 35, "sl_5": 35,
+    "sl_6": 35, "sl_7": 40, "sl_8": 15, "sl_9": 15, "sl_10": 15,
+}

domain_mixture_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b6f9e71e38cdd329881f75592d8b847f062c1360daac2e5fbb20f99aee63b26
+size 6363

domain_mixture_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2ca2e6ed1f78d0a462b425394fb748b4b489b079b1aa320753149e5368e2015
+size 8979

farseer_scaling_law/__init__.py

@@ -0,0 +1 @@
+"""Farseer scaling law benchmark dataset."""

farseer_scaling_law/laws.py

@@ -0,0 +1,99 @@
+"""Scaling laws for the Farseer N-D benchmark split.
+
+X columns: [N (Model Size), D (Training Tokens)]
+
+Primary law:
+    L(N, D) = exp(s * N^q + S) + exp(B * N^b + Q) * D^(-exp(A * N^a + E))
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+_EXP_CLIP = 50.0
+
+
+# Farseer law (9 params):
+#   exp(s * N^q + S) + exp(B * N^b + Q) * D^(-exp(A * N^a + E))
+# theta: [E, s, q, S, B, b, Q, A, a]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    N = ops.clamp_min(X[:, 0], _EPS)
+    D = ops.clamp_min(X[:, 1], _EPS)
+
+    E = theta[:, 0]
+    s = theta[:, 1]
+    q = theta[:, 2]
+    S = theta[:, 3]
+    B = theta[:, 4]
+    b = theta[:, 5]
+    Q = theta[:, 6]
+    A = theta[:, 7]
+    a = theta[:, 8]
+
+    log_N = xp.log(ops.clamp_min(N, _EPS))
+    log_D = xp.log(ops.clamp_min(D, _EPS))
+
+    N_pow_q = N[None, :] ** q[:, None]
+    N_pow_b = N[None, :] ** b[:, None]
+    N_pow_a = N[None, :] ** a[:, None]
+
+    term1_arg = ops.clamp(s[:, None] * N_pow_q + S[:, None], min=-_EXP_CLIP, max=_EXP_CLIP)
+    bn_arg = ops.clamp(B[:, None] * N_pow_b + Q[:, None], min=-_EXP_CLIP, max=_EXP_CLIP)
+    exp_an_arg = ops.clamp(A[:, None] * N_pow_a + E[:, None], min=-_EXP_CLIP, max=_EXP_CLIP)
+
+    term1 = ops.exp(term1_arg)
+    exp_an = ops.exp(exp_an_arg)
+    an = -exp_an
+    log_term2 = ops.clamp(bn_arg + an * log_D[None, :], min=-_EXP_CLIP, max=_EXP_CLIP)
+    term2 = ops.exp(log_term2)
+    pred = term1 + term2
+
+    ones = xp.ones_like(pred)
+
+    d_E = term2 * log_D[None, :] * an
+    d_s = term1 * N_pow_q
+    d_q = term1 * s[:, None] * N_pow_q * log_N[None, :]
+    d_S = term1
+    d_B = term2 * N_pow_b
+    d_b = term2 * B[:, None] * N_pow_b * log_N[None, :]
+    d_Q = term2
+    d_A = term2 * log_D[None, :] * an * N_pow_a
+    d_a = term2 * log_D[None, :] * an * A[:, None] * N_pow_a * log_N[None, :]
+
+    jac = ops.stack([d_E, d_s, d_q, d_S, d_B, d_b, d_Q, d_A, d_a], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+LAW_REGISTRY = {"sl_1": sl_1}
+PARAM_COUNTS = {"sl_1": 9}
+
+# Data ranges based on the integrated benchmark split:
+#   N ∈ [9.96e7, 2.51e10], D ∈ [1.0e9, 5.12e11], loss ∈ [0.438, 0.675]
+PARAM_BOUNDS = {
+    # Bounds centered around the paper / notebook ground-truth parameters,
+    # but widened substantially to reduce prior pressure while preserving
+    # the sign of the exponent terms: q > 0, b < 0, a > 0.
+    # E=3.133347198805445, s=-0.062465473, q=0.13, S=0.1284880679442551,
+    # B=230.73437075885855, b=-0.1729, Q=-1.544209554,
+    # A=-1.665630816, a=0.0458999999999619
+    "sl_1": [
+        (1.0, 6.0),        # E
+        (-1.0, 0.3),       # s
+        (0.01, 0.5),       # q > 0
+        (-1.0, 1.0),       # S
+        (10.0, 1000.0),    # B
+        (-0.6, -0.01),     # b < 0
+        (-5.0, 1.0),       # Q
+        (-5.0, 1.0),       # A
+        (0.001, 0.25),     # a > 0
+    ],
+}

farseer_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f886cce70555fed73c6ecbdc6588edc0cb0947a00db36e15c8795afcba280f3d
+size 2841

farseer_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98c4167b4b111814bcf8450bef0ec975239da067dd4f42ef6b71f4c1667705bc
+size 7363

lr_bsz_scaling_law/laws.py

@@ -0,0 +1,1188 @@
+"""Scaling laws for learning-rate / batch-size / data-size / model-size."""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-30
+
+
+# Scaling law 1 (15 params):
+#   Degree-2 polynomial in log-space of 4 features, predicting log(lm_loss).
+#   Output = exp(poly).
+#
+#   Features after log: z = [log(lr), log(bsz), log(data_size), log(non_embedding_param_size)]
+#   Polynomial terms (15 total):
+#     bias, z0, z1, z2, z3, z0^2, z1^2, z2^2, z3^2, z0*z1, z0*z2, z0*z3, z1*z2, z1*z3, z2*z3
+#
+# theta: (B, 15)
+# X: [lr, bsz, data_size, non_embedding_param_size]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    xp = ops.xp
+
+    x0 = ops.clamp_min(X[:, 0], _EPS)
+    x1 = ops.clamp_min(X[:, 1], _EPS)
+    x2 = ops.clamp_min(X[:, 2], _EPS)
+    x3 = ops.clamp_min(X[:, 3], _EPS)
+
+    z0 = xp.log(x0)
+    z1 = xp.log(x1)
+    z2 = xp.log(x2)
+    z3 = xp.log(x3)
+
+    # Build feature matrix: (M, 15)
+    ones = z0 * 0.0 + 1.0
+    if backend == "torch":
+        features = xp.stack([
+            ones, z0, z1, z2, z3,
+            z0 * z0, z1 * z1, z2 * z2, z3 * z3,
+            z0 * z1, z0 * z2, z0 * z3, z1 * z2, z1 * z3, z2 * z3,
+        ], dim=-1)  # (M, 15)
+    else:
+        features = xp.stack([
+            ones, z0, z1, z2, z3,
+            z0 * z0, z1 * z1, z2 * z2, z3 * z3,
+            z0 * z1, z0 * z2, z0 * z3, z1 * z2, z1 * z3, z2 * z3,
+        ], axis=-1)  # (M, 15)
+
+    # theta: (B, 15), features: (M, 15) -> log_pred: (B, M)
+    if backend == "torch":
+        log_pred = xp.matmul(theta, features.T)
+    else:
+        log_pred = theta @ features.T
+
+    pred = ops.exp(log_pred)
+
+    # Jacobian: d pred / d theta_i = pred * features[:, i]
+    # pred: (B, M), features: (M, 15) -> jac: (B, M, 15)
+    jac = pred[:, :, None] * features[None, :, :]
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_2 (26p): Physics-inspired softplus-penalty model
+# base = L_inf + Cp*exp(-ap*p) + Cd*exp(-ad*s) + Cdp*exp(-adp*(s-k*p)) + Cbb*exp(-abb*v)
+# u_star = u0 + up*p + us*s + uv*v;  v_star = v0 + vp*p + vs*s
+# cL = softplus(cL0+cLp*p+cLs*s+cLv*v);  cB = softplus(cB0+cBp*p+cBs*s+cBv*v)
+# penalty = cL*du^2 + cB*dv^2 + 2*rho*sqrt(cL*cB)*du*dv
+# loss = base + penalty
+# theta: [L_inf, Cp, ap, Cd, ad, Cdp, adp, k, u0, up, us, uv, v0, vp, vs,
+#          cL0, cLp, cLs, cB0, cBp, cBs, rho, cLv, cBv, Cbb, abb]
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    u = xp.log(lr); v = xp.log(bsz); s = xp.log(D); p = xp.log(P)
+    t = [theta[:, i] for i in range(26)]
+    L_inf, Cp, ap, Cd, ad, Cdp, adp, k = t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7]
+    u0, up_, us, uv, v0, vp_, vs = t[8], t[9], t[10], t[11], t[12], t[13], t[14]
+    cL0, cLp, cLs, cB0, cBp, cBs, rho = t[15], t[16], t[17], t[18], t[19], t[20], t[21]
+    cLv, cBv, Cbb, abb = t[22], t[23], t[24], t[25]
+
+    def softplus(x):
+        return xp.log(1.0 + ops.exp(ops.clamp(x, min=-20.0, max=20.0)))
+
+    def sigmoid(x):
+        ex = ops.exp(ops.clamp(x, min=-20.0, max=20.0))
+        return ex / (1.0 + ex)
+
+    # Base loss (power-law terms in exp form)
+    Cp_s = softplus(Cp); ap_s = softplus(ap)
+    Cd_s = softplus(Cd); ad_s = softplus(ad)
+    Cdp_s = softplus(Cdp); adp_s = softplus(adp)
+    Cbb_s = softplus(Cbb); abb_s = softplus(abb)
+
+    # Sigmoid for softplus derivatives
+    sig_Cp = sigmoid(Cp); sig_ap = sigmoid(ap)
+    sig_Cd = sigmoid(Cd); sig_ad = sigmoid(ad)
+    sig_Cdp = sigmoid(Cdp); sig_adp = sigmoid(adp)
+    sig_Cbb = sigmoid(Cbb); sig_abb = sigmoid(abb)
+
+    exp_P = ops.exp(-ap_s[:, None] * p[None, :])         # (B, M)
+    exp_D = ops.exp(-ad_s[:, None] * s[None, :])         # (B, M)
+    exp_DP = ops.exp(-adp_s[:, None] * (s[None, :] - k[:, None] * p[None, :]))  # (B, M)
+    exp_V = ops.exp(-abb_s[:, None] * v[None, :])        # (B, M)
+
+    base = (L_inf[:, None]
+            + Cp_s[:, None] * exp_P
+            + Cd_s[:, None] * exp_D
+            + Cdp_s[:, None] * exp_DP
+            + Cbb_s[:, None] * exp_V)
+
+    # Optimal lr and bsz
+    u_star = u0[:, None] + up_[:, None] * p[None, :] + us[:, None] * s[None, :] + uv[:, None] * v[None, :]
+    v_star = v0[:, None] + vp_[:, None] * p[None, :] + vs[:, None] * s[None, :]
+    du = u[None, :] - u_star
+    dv = v[None, :] - v_star
+
+    # State-dependent curvatures
+    zL = cL0[:, None] + cLp[:, None] * p[None, :] + cLs[:, None] * s[None, :] + cLv[:, None] * v[None, :]
+    zB = cB0[:, None] + cBp[:, None] * p[None, :] + cBs[:, None] * s[None, :] + cBv[:, None] * v[None, :]
+    cL = softplus(zL)
+    cB = softplus(zB)
+    sig_zL = sigmoid(zL)  # (B, M)
+    sig_zB = sigmoid(zB)  # (B, M)
+
+    # Correlated penalty
+    rho_t = xp.tanh(rho[:, None]) if hasattr(xp, 'tanh') else (ops.exp(2.0 * rho[:, None]) - 1.0) / (ops.exp(2.0 * rho[:, None]) + 1.0)
+    g = (cL * cB) ** 0.5
+    penalty = cL * du ** 2 + cB * dv ** 2 + 2.0 * rho_t * g * du * dv
+
+    pred = base + penalty
+
+    # ---- Jacobian computation ----
+    # B_dim = theta.shape[0], M = X.shape[0], P = 26
+    ones_BM = pred * 0.0 + 1.0  # (B, M)
+    zeros_BM = pred * 0.0       # (B, M)
+
+    # Helper: g = sqrt(cL*cB), dg/dcL = 0.5*cB/g, dg/dcB = 0.5*cL/g
+    g_safe = ops.clamp_min(g, _EPS)
+    dg_dcL = 0.5 * cB / g_safe  # (B, M)
+    dg_dcB = 0.5 * cL / g_safe  # (B, M)
+
+    # d(penalty)/d(cL) = du^2 + 2*rho_t*dg_dcL*du*dv
+    dpen_dcL = du ** 2 + 2.0 * rho_t * dg_dcL * du * dv
+    # d(penalty)/d(cB) = dv^2 + 2*rho_t*dg_dcB*du*dv
+    dpen_dcB = dv ** 2 + 2.0 * rho_t * dg_dcB * du * dv
+
+    # d(penalty)/d(du) = 2*cL*du + 2*rho_t*g*dv
+    dpen_ddu = 2.0 * cL * du + 2.0 * rho_t * g * dv
+    # d(penalty)/d(dv) = 2*cB*dv + 2*rho_t*g*du
+    dpen_ddv = 2.0 * cB * dv + 2.0 * rho_t * g * du
+
+    # du = u - u_star, dv = v - v_star
+    # d(du)/d(u0) = -1, d(du)/d(up) = -p, d(du)/d(us) = -s, d(du)/d(uv) = -v
+    # d(dv)/d(v0) = -1, d(dv)/d(vp) = -p, d(dv)/d(vs) = -s
+
+    # d(penalty)/d(rho) = (1 - tanh(rho)^2) * 2*g*du*dv
+    drho_t = 1.0 - rho_t ** 2  # (B, M) or (B, 1) -> broadcast
+    dpen_drho = drho_t * 2.0 * g * du * dv  # (B, M)
+
+    # Now compute each partial:
+    # t[0] = L_inf: d/dL_inf = 1
+    d_0 = ones_BM
+
+    # t[1] = Cp: d/dCp = sig(Cp) * exp_P
+    d_1 = sig_Cp[:, None] * exp_P
+
+    # t[2] = ap: d/dap = sig(ap) * Cp_s * (-p) * exp_P
+    d_2 = sig_ap[:, None] * Cp_s[:, None] * (-p[None, :]) * exp_P
+
+    # t[3] = Cd: d/dCd = sig(Cd) * exp_D
+    d_3 = sig_Cd[:, None] * exp_D
+
+    # t[4] = ad: d/dad = sig(ad) * Cd_s * (-s) * exp_D
+    d_4 = sig_ad[:, None] * Cd_s[:, None] * (-s[None, :]) * exp_D
+
+    # t[5] = Cdp: d/dCdp = sig(Cdp) * exp_DP
+    d_5 = sig_Cdp[:, None] * exp_DP
+
+    # t[6] = adp: d/dadp = sig(adp) * Cdp_s * (-(s-k*p)) * exp_DP
+    d_6 = sig_adp[:, None] * Cdp_s[:, None] * (-(s[None, :] - k[:, None] * p[None, :])) * exp_DP
+
+    # t[7] = k: d/dk = Cdp_s * adp_s * p * exp_DP
+    d_7 = Cdp_s[:, None] * adp_s[:, None] * p[None, :] * exp_DP
+
+    # t[8] = u0: d/du0 = dpen_ddu * (-1)
+    d_8 = dpen_ddu * (-1.0)
+
+    # t[9] = up: d/dup = dpen_ddu * (-p)
+    d_9 = dpen_ddu * (-p[None, :])
+
+    # t[10] = us: d/dus = dpen_ddu * (-s)
+    d_10 = dpen_ddu * (-s[None, :])
+
+    # t[11] = uv: d/duv = dpen_ddu * (-v)
+    d_11 = dpen_ddu * (-v[None, :])
+
+    # t[12] = v0: d/dv0 = dpen_ddv * (-1)
+    d_12 = dpen_ddv * (-1.0)
+
+    # t[13] = vp: d/dvp = dpen_ddv * (-p)
+    d_13 = dpen_ddv * (-p[None, :])
+
+    # t[14] = vs: d/dvs = dpen_ddv * (-s)
+    d_14 = dpen_ddv * (-s[None, :])
+
+    # t[15] = cL0: d/dcL0 = dpen_dcL * sig_zL * 1
+    d_15 = dpen_dcL * sig_zL
+
+    # t[16] = cLp: d/dcLp = dpen_dcL * sig_zL * p
+    d_16 = dpen_dcL * sig_zL * p[None, :]
+
+    # t[17] = cLs: d/dcLs = dpen_dcL * sig_zL * s
+    d_17 = dpen_dcL * sig_zL * s[None, :]
+
+    # t[18] = cB0: d/dcB0 = dpen_dcB * sig_zB * 1
+    d_18 = dpen_dcB * sig_zB
+
+    # t[19] = cBp: d/dcBp = dpen_dcB * sig_zB * p
+    d_19 = dpen_dcB * sig_zB * p[None, :]
+
+    # t[20] = cBs: d/dcBs = dpen_dcB * sig_zB * s
+    d_20 = dpen_dcB * sig_zB * s[None, :]
+
+    # t[21] = rho: d/drho = dpen_drho
+    d_21 = dpen_drho
+
+    # t[22] = cLv: d/dcLv = dpen_dcL * sig_zL * v
+    d_22 = dpen_dcL * sig_zL * v[None, :]
+
+    # t[23] = cBv: d/dcBv = dpen_dcB * sig_zB * v
+    d_23 = dpen_dcB * sig_zB * v[None, :]
+
+    # t[24] = Cbb: d/dCbb = sig(Cbb) * exp_V
+    d_24 = sig_Cbb[:, None] * exp_V
+
+    # t[25] = abb: d/dabb = sig(abb) * Cbb_s * (-v) * exp_V
+    d_25 = sig_abb[:, None] * Cbb_s[:, None] * (-v[None, :]) * exp_V
+
+    jac = ops.stack([d_0, d_1, d_2, d_3, d_4, d_5, d_6, d_7,
+                     d_8, d_9, d_10, d_11, d_12, d_13, d_14,
+                     d_15, d_16, d_17, d_18, d_19, d_20, d_21,
+                     d_22, d_23, d_24, d_25], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_3 (24p): Chinchilla power-law + decoupled LR/BSZ quadratic valleys
+# L = E + A*N^(-alpha) + B*D^(-beta) + F/(N^wN * D^wD)
+#   + C_eff*(log(lr)-opt_lr)^2 + G_eff*(log(bsz)-opt_bsz)^2
+# theta: [E, A, alpha, B, beta, F, wN, wD, C0, CN, CD, CB, mu0, muN, muD, muB, muND,
+#          G0, GN, GD, nu0, nuN, nuD, nuND]
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    lnlr = xp.log(lr); lnb = xp.log(bsz); lnD = xp.log(D); lnP = xp.log(P)
+    t = [theta[:, i] for i in range(24)]
+    E, A, alpha, B, beta, F, wN, wD = t[:8]
+    C0, CN, CD, CB, mu0, muN, muD, muB, muND = t[8:17]
+    G0, GN, GD, nu0, nuN, nuD, nuND = t[17:24]
+
+    # Intermediate computations
+    P_neg_alpha = P[None, :] ** (-alpha[:, None])       # (B, M)
+    D_neg_beta = D[None, :] ** (-beta[:, None])         # (B, M)
+    PwN = P[None, :] ** wN[:, None]                     # (B, M)
+    DwD = D[None, :] ** wD[:, None]                     # (B, M)
+    denom = ops.clamp_min(PwN * DwD, _EPS)
+    joint_term = F[:, None] / denom                     # (B, M)
+
+    base = (E[:, None]
+            + A[:, None] * P_neg_alpha
+            + B[:, None] * D_neg_beta
+            + joint_term)
+
+    opt_lr = mu0[:, None] + muN[:, None]*lnP[None, :] + muD[:, None]*lnD[None, :] + muB[:, None]*lnb[None, :] + muND[:, None]*lnP[None, :]*lnD[None, :]
+    lr_exp = CN[:, None]*lnP[None, :] + CD[:, None]*lnD[None, :] + CB[:, None]*lnb[None, :]
+    C_eff = C0[:, None] * ops.exp(lr_exp)
+    dlr = lnlr[None, :] - opt_lr
+    lr_pen = C_eff * dlr ** 2
+
+    opt_bsz = nu0[:, None] + nuN[:, None]*lnP[None, :] + nuD[:, None]*lnD[None, :] + nuND[:, None]*lnP[None, :]*lnD[None, :]
+    bsz_exp = GN[:, None]*lnP[None, :] + GD[:, None]*lnD[None, :]
+    G_eff = G0[:, None] * ops.exp(bsz_exp)
+    dbsz = lnb[None, :] - opt_bsz
+    bsz_pen = G_eff * dbsz ** 2
+
+    pred = base + lr_pen + bsz_pen
+
+    # ---- Jacobian ----
+    ones_BM = pred * 0.0 + 1.0
+
+    # d/dE = 1
+    d_E = ones_BM
+
+    # d/dA = P^(-alpha)
+    d_A = P_neg_alpha
+
+    # d/dalpha = A * P^(-alpha) * (-lnP) = -A * P_neg_alpha * lnP
+    d_alpha = -A[:, None] * P_neg_alpha * lnP[None, :]
+
+    # d/dB = D^(-beta)
+    d_B = D_neg_beta
+
+    # d/dbeta = -B * D^(-beta) * lnD
+    d_beta = -B[:, None] * D_neg_beta * lnD[None, :]
+
+    # d/dF = 1/denom
+    d_F = 1.0 / denom
+
+    # d/dwN = F * d/dwN(1/(P^wN * D^wD)) = F * (-lnP) / denom = -joint_term * lnP
+    d_wN = -joint_term * lnP[None, :]
+
+    # d/dwD = -joint_term * lnD
+    d_wD = -joint_term * lnD[None, :]
+
+    # LR penalty partials
+    # C_eff = C0 * exp(lr_exp), dlr = lnlr - opt_lr
+    # lr_pen = C_eff * dlr^2
+
+    # d/dC0 = exp(lr_exp) * dlr^2
+    d_C0 = ops.exp(lr_exp) * dlr ** 2
+
+    # d/dCN = C_eff * lnP * dlr^2 (chain through lr_exp)
+    d_CN = C_eff * lnP[None, :] * dlr ** 2
+
+    # d/dCD = C_eff * lnD * dlr^2
+    d_CD = C_eff * lnD[None, :] * dlr ** 2
+
+    # d/dCB = C_eff * lnb * dlr^2
+    d_CB = C_eff * lnb[None, :] * dlr ** 2
+
+    # d/dmu0 = C_eff * 2*dlr * (-1) = -2*C_eff*dlr
+    d_mu0 = -2.0 * C_eff * dlr
+
+    # d/dmuN = -2*C_eff*dlr * lnP
+    d_muN = -2.0 * C_eff * dlr * lnP[None, :]
+
+    # d/dmuD = -2*C_eff*dlr * lnD
+    d_muD = -2.0 * C_eff * dlr * lnD[None, :]
+
+    # d/dmuB = -2*C_eff*dlr * lnb
+    d_muB = -2.0 * C_eff * dlr * lnb[None, :]
+
+    # d/dmuND = -2*C_eff*dlr * lnP*lnD
+    d_muND = -2.0 * C_eff * dlr * lnP[None, :] * lnD[None, :]
+
+    # BSZ penalty partials
+    # G_eff = G0 * exp(bsz_exp), dbsz = lnb - opt_bsz
+    # bsz_pen = G_eff * dbsz^2
+
+    # d/dG0 = exp(bsz_exp) * dbsz^2
+    d_G0 = ops.exp(bsz_exp) * dbsz ** 2
+
+    # d/dGN = G_eff * lnP * dbsz^2
+    d_GN = G_eff * lnP[None, :] * dbsz ** 2
+
+    # d/dGD = G_eff * lnD * dbsz^2
+    d_GD = G_eff * lnD[None, :] * dbsz ** 2
+
+    # d/dnu0 = -2*G_eff*dbsz
+    d_nu0 = -2.0 * G_eff * dbsz
+
+    # d/dnuN = -2*G_eff*dbsz * lnP
+    d_nuN = -2.0 * G_eff * dbsz * lnP[None, :]
+
+    # d/dnuD = -2*G_eff*dbsz * lnD
+    d_nuD = -2.0 * G_eff * dbsz * lnD[None, :]
+
+    # d/dnuND = -2*G_eff*dbsz * lnP*lnD
+    d_nuND = -2.0 * G_eff * dbsz * lnP[None, :] * lnD[None, :]
+
+    # Order: [E, A, alpha, B, beta, F, wN, wD,
+    #         C0, CN, CD, CB, mu0, muN, muD, muB, muND,
+    #         G0, GN, GD, nu0, nuN, nuD, nuND]
+    jac = ops.stack([d_E, d_A, d_alpha, d_B, d_beta, d_F, d_wN, d_wD,
+                     d_C0, d_CN, d_CD, d_CB, d_mu0, d_muN, d_muD, d_muB, d_muND,
+                     d_G0, d_GN, d_GD, d_nu0, d_nuN, d_nuD, d_nuND], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_4 (20p): Log-polynomial-2 + inverse features
+# log(loss) = w . phi(X), loss = exp(...)
+# phi = [1, log(lr), log(bsz), log(D), log(P),
+#        log(lr)^2, log(bsz)^2, log(D)^2, log(P)^2,
+#        log(lr)*log(bsz), log(lr)*log(D), log(lr)*log(P),
+#        log(bsz)*log(D), log(bsz)*log(P), log(D)*log(P),
+#        log(D)-log(P), 1/bsz, 1/bsz^2, 1/D, 1/P]
+# theta: 20 weights
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    z0 = xp.log(lr); z1 = xp.log(bsz); z2 = xp.log(D); z3 = xp.log(P)
+    ones = z0 * 0.0 + 1.0
+    feat_list = [
+        ones, z0, z1, z2, z3,
+        z0*z0, z1*z1, z2*z2, z3*z3,
+        z0*z1, z0*z2, z0*z3, z1*z2, z1*z3, z2*z3,
+        z2 - z3,
+        1.0 / bsz, 1.0 / (bsz * bsz), 1.0 / D, 1.0 / P,
+    ]
+    if backend == "torch":
+        features = xp.stack(feat_list, dim=-1)
+        log_pred = xp.matmul(theta, features.T)
+    else:
+        features = xp.stack(feat_list, axis=-1)
+        log_pred = theta @ features.T
+    pred = ops.exp(log_pred)
+
+    # Jacobian: same as sl_1, d pred / d theta_i = pred * features[:, i]
+    jac = pred[:, :, None] * features[None, :, :]
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_5 (19p): Chinchilla + exp-decay + LR quadratic penalty
+# u=log(lr), v=log(bsz), s=log(D), n=log(P)
+# u_star = u0+kb*v+kn*n+kd*s; lr_amp = clr0*exp(-wb*v-wn*n-ws*s)
+# loss = L0 + AN*exp(-aN*n) + AD*exp(-aD*s) + AB*exp(-aB*v)
+#      + AR*exp(-aR*(s-n)^2) + AX*exp(-aX*(s-v)) + lr_amp*(u-u_star)^2
+# theta: [L0, AN, aN, AD, aD, AB, aB, clr0, u0, kb, kn, kd, wb, wn, ws, AR, aR, AX, aX]
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    u = xp.log(lr); v = xp.log(bsz); s = xp.log(D); n = xp.log(P)
+    t = [theta[:, i] for i in range(19)]
+    L0, AN, aN, AD, aD, AB, aB = t[:7]
+    clr0, u0, kb, kn, kd, wb, wn, ws = t[7:15]
+    AR, aR, AX, aX = t[15:19]
+
+    exp_N = ops.exp(-aN[:, None] * n[None, :])            # (B, M)
+    exp_D = ops.exp(-aD[:, None] * s[None, :])            # (B, M)
+    exp_V = ops.exp(-aB[:, None] * v[None, :])            # (B, M)
+
+    base = (L0[:, None]
+            + AN[:, None] * exp_N
+            + AD[:, None] * exp_D
+            + AB[:, None] * exp_V)
+
+    sn_diff = s[None, :] - n[None, :]
+    sn_diff_sq = sn_diff ** 2
+    exp_R = ops.exp(-aR[:, None] * sn_diff_sq)            # (B, M)
+    ratio_term = AR[:, None] * exp_R
+
+    sv_diff = s[None, :] - v[None, :]
+    exp_X = ops.exp(-aX[:, None] * sv_diff)               # (B, M)
+    cross_term = AX[:, None] * exp_X
+
+    u_star = u0[:, None] + kb[:, None]*v[None, :] + kn[:, None]*n[None, :] + kd[:, None]*s[None, :]
+    lr_exp_arg = -wb[:, None]*v[None, :] - wn[:, None]*n[None, :] - ws[:, None]*s[None, :]
+    lr_amp = clr0[:, None] * ops.exp(lr_exp_arg)
+    du = u[None, :] - u_star
+    du_sq = du ** 2
+    lr_pen = lr_amp * du_sq
+
+    pred = base + ratio_term + cross_term + lr_pen
+
+    # ---- Jacobian ----
+    ones_BM = pred * 0.0 + 1.0
+
+    # t[0] = L0
+    d_0 = ones_BM
+
+    # t[1] = AN: d/dAN = exp_N
+    d_1 = exp_N
+
+    # t[2] = aN: d/daN = AN * (-n) * exp_N
+    d_2 = AN[:, None] * (-n[None, :]) * exp_N
+
+    # t[3] = AD: d/dAD = exp_D
+    d_3 = exp_D
+
+    # t[4] = aD: d/daD = AD * (-s) * exp_D
+    d_4 = AD[:, None] * (-s[None, :]) * exp_D
+
+    # t[5] = AB: d/dAB = exp_V
+    d_5 = exp_V
+
+    # t[6] = aB: d/daB = AB * (-v) * exp_V
+    d_6 = AB[:, None] * (-v[None, :]) * exp_V
+
+    # lr_pen = clr0 * exp(lr_exp_arg) * du^2
+    # lr_amp = clr0 * exp(lr_exp_arg)
+    exp_lr = ops.exp(lr_exp_arg)
+
+    # t[7] = clr0: d/dclr0 = exp(lr_exp_arg) * du^2
+    d_7 = exp_lr * du_sq
+
+    # d(lr_pen)/d(du) = lr_amp * 2*du; d(du)/d(u0) = -1
+    dlrpen_ddu = 2.0 * lr_amp * du
+
+    # t[8] = u0: d/du0 = -dlrpen_ddu
+    d_8 = -dlrpen_ddu
+
+    # t[9] = kb: d/dkb = dlrpen_ddu * (-v)
+    d_9 = dlrpen_ddu * (-v[None, :])
+
+    # t[10] = kn: d/dkn = dlrpen_ddu * (-n)
+    d_10 = dlrpen_ddu * (-n[None, :])
+
+    # t[11] = kd: d/dkd = dlrpen_ddu * (-s)
+    d_11 = dlrpen_ddu * (-s[None, :])
+
+    # t[12] = wb: d/dwb = lr_pen * (-v)  (chain through exp)
+    d_12 = lr_pen * (-v[None, :])
+
+    # t[13] = wn: d/dwn = lr_pen * (-n)
+    d_13 = lr_pen * (-n[None, :])
+
+    # t[14] = ws: d/dws = lr_pen * (-s)
+    d_14 = lr_pen * (-s[None, :])
+
+    # t[15] = AR: d/dAR = exp_R
+    d_15 = exp_R
+
+    # t[16] = aR: d/daR = AR * (-(s-n)^2) * exp_R
+    d_16 = AR[:, None] * (-sn_diff_sq) * exp_R
+
+    # t[17] = AX: d/dAX = exp_X
+    d_17 = exp_X
+
+    # t[18] = aX: d/daX = AX * (-(s-v)) * exp_X
+    d_18 = AX[:, None] * (-sv_diff) * exp_X
+
+    jac = ops.stack([d_0, d_1, d_2, d_3, d_4, d_5, d_6,
+                     d_7, d_8, d_9, d_10, d_11, d_12, d_13, d_14,
+                     d_15, d_16, d_17, d_18], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_6 (14p): L_inf + exp(partial poly2)
+# loss = L_inf + exp(w0 + w_d*log(D) + w_p*log(P) + w_dp*log(D)*log(P)
+#                   + w_lr*log(lr) + w_lr2*log(lr)^2
+#                   + w_bsz*log(bsz) + w_bsz2*log(bsz)^2
+#                   + w_lrbsz*log(lr)*log(bsz)
+#                   + w_lrD*log(lr)*log(D) + w_lrP*log(lr)*log(P)
+#                   + w_bszD*log(bsz)*log(D) + w_bszP*log(bsz)*log(P))
+# theta: [L_inf, w0, w_d, w_p, w_dp, w_lr, w_lr2, w_bsz, w_bsz2,
+#          w_lrbsz, w_lrD, w_lrP, w_bszD, w_bszP]
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    lnlr = xp.log(lr); lnb = xp.log(bsz); lnD = xp.log(D); lnP = xp.log(P)
+    t = [theta[:, i] for i in range(14)]
+    L_inf = t[0]
+    exponent = (t[1][:, None]
+                + t[2][:, None]*lnD[None, :] + t[3][:, None]*lnP[None, :]
+                + t[4][:, None]*lnD[None, :]*lnP[None, :]
+                + t[5][:, None]*lnlr[None, :] + t[6][:, None]*lnlr[None, :]**2
+                + t[7][:, None]*lnb[None, :] + t[8][:, None]*lnb[None, :]**2
+                + t[9][:, None]*lnlr[None, :]*lnb[None, :]
+                + t[10][:, None]*lnlr[None, :]*lnD[None, :] + t[11][:, None]*lnlr[None, :]*lnP[None, :]
+                + t[12][:, None]*lnb[None, :]*lnD[None, :] + t[13][:, None]*lnb[None, :]*lnP[None, :])
+    exponent = ops.clamp(exponent, min=-50.0, max=50.0)
+    exp_term = ops.exp(exponent)
+    pred = L_inf[:, None] + exp_term
+
+    # ---- Jacobian ----
+    # d/dL_inf = 1
+    ones_BM = pred * 0.0 + 1.0
+    d_0 = ones_BM
+
+    # For t[1..13]: d/dt_i = exp_term * (feature_i)
+    # feature for t[1] = 1 (w0)
+    d_1 = exp_term
+
+    # t[2] = w_d: feature = lnD
+    d_2 = exp_term * lnD[None, :]
+
+    # t[3] = w_p: feature = lnP
+    d_3 = exp_term * lnP[None, :]
+
+    # t[4] = w_dp: feature = lnD*lnP
+    d_4 = exp_term * lnD[None, :] * lnP[None, :]
+
+    # t[5] = w_lr: feature = lnlr
+    d_5 = exp_term * lnlr[None, :]
+
+    # t[6] = w_lr2: feature = lnlr^2
+    d_6 = exp_term * lnlr[None, :] ** 2
+
+    # t[7] = w_bsz: feature = lnb
+    d_7 = exp_term * lnb[None, :]
+
+    # t[8] = w_bsz2: feature = lnb^2
+    d_8 = exp_term * lnb[None, :] ** 2
+
+    # t[9] = w_lrbsz: feature = lnlr*lnb
+    d_9 = exp_term * lnlr[None, :] * lnb[None, :]
+
+    # t[10] = w_lrD: feature = lnlr*lnD
+    d_10 = exp_term * lnlr[None, :] * lnD[None, :]
+
+    # t[11] = w_lrP: feature = lnlr*lnP
+    d_11 = exp_term * lnlr[None, :] * lnP[None, :]
+
+    # t[12] = w_bszD: feature = lnb*lnD
+    d_12 = exp_term * lnb[None, :] * lnD[None, :]
+
+    # t[13] = w_bszP: feature = lnb*lnP
+    d_13 = exp_term * lnb[None, :] * lnP[None, :]
+
+    jac = ops.stack([d_0, d_1, d_2, d_3, d_4, d_5, d_6, d_7,
+                     d_8, d_9, d_10, d_11, d_12, d_13], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_7 (31p): E + exp(poly2_A) + exp(poly2_B) dual-term
+# features = [1, x1..x4, x1^2..x4^2, x1*x2, x1*x3, x1*x4, x2*x3, x2*x4, x3*x4]
+# (15 features from log inputs)
+# loss = E + exp(features . w1) + exp(features . w2)
+# theta: [E, w1[0..14], w2[0..14]]
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    z0 = xp.log(lr); z1 = xp.log(bsz); z2 = xp.log(D); z3 = xp.log(P)
+    ones = z0 * 0.0 + 1.0
+    feat_list = [
+        ones, z0, z1, z2, z3,
+        z0*z0, z1*z1, z2*z2, z3*z3,
+        z0*z1, z0*z2, z0*z3, z1*z2, z1*z3, z2*z3,
+    ]
+    if backend == "torch":
+        features = xp.stack(feat_list, dim=-1)  # (M, 15)
+    else:
+        features = xp.stack(feat_list, axis=-1)  # (M, 15)
+    E = theta[:, 0]
+    w1 = theta[:, 1:16]   # (B, 15)
+    w2 = theta[:, 16:31]  # (B, 15)
+    if backend == "torch":
+        log1 = xp.matmul(w1, features.T)
+        log2 = xp.matmul(w2, features.T)
+    else:
+        log1 = w1 @ features.T
+        log2 = w2 @ features.T
+    log1 = ops.clamp(log1, min=-50.0, max=50.0)
+    log2 = ops.clamp(log2, min=-50.0, max=50.0)
+    exp1 = ops.exp(log1)
+    exp2 = ops.exp(log2)
+    pred = E[:, None] + exp1 + exp2
+
+    # ---- Jacobian ----
+    # d/dE = 1
+    ones_BM = pred * 0.0 + 1.0
+
+    # d/dw1_i = exp1 * features[:, i] -> (B, M)
+    # d/dw2_i = exp2 * features[:, i] -> (B, M)
+    # jac_w1: (B, M, 15) = exp1[:,:,None] * features[None,:,:]
+    jac_w1 = exp1[:, :, None] * features[None, :, :]  # (B, M, 15)
+    jac_w2 = exp2[:, :, None] * features[None, :, :]  # (B, M, 15)
+
+    # Build full jac: [d_E, jac_w1[...,0], ..., jac_w1[...,14], jac_w2[...,0], ..., jac_w2[...,14]]
+    partials = [ones_BM]
+    for i in range(15):
+        partials.append(jac_w1[:, :, i])
+    for i in range(15):
+        partials.append(jac_w2[:, :, i])
+
+    jac = ops.stack(partials, axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_8 (20p): Chinchilla + asymmetric tanh-skewed penalties
+# u=log(lr), v=log(bsz), s=log(D), p=log(P)
+# term_P = cP*exp(-aP*p); term_D = cD*exp(-aD*s); term_R = cR*exp(-aR*(s-p))
+# lr_opt = phi0+phi_b*v+phi_p*p+phi_d*s; dev=u-lr_opt
+# lr_pen = k_lr*dev^2*(1+a_lr*tanh(dev))
+# ns = u-0.5*v; ns_opt = psi0+psi_p*p+psi_d*s; dev_ns=ns-ns_opt
+# ns_pen = k_ns*dev_ns^2*(1+a_ns*tanh(dev_ns))
+# dp_pen = k_dp*((s-p)-delta0)^2
+# loss = L0 + term_P + term_D + term_R + lr_pen + ns_pen + dp_pen
+# theta: [L0, cP, aP, cD, aD, cR, aR, phi0, phi_b, phi_p, phi_d,
+#          k_lr, a_lr, psi0, psi_p, psi_d, k_ns, a_ns, delta0, k_dp]
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    u = xp.log(lr); v = xp.log(bsz); s = xp.log(D); p = xp.log(P)
+    t = [theta[:, i] for i in range(20)]
+
+    def softplus(x):
+        return xp.log(1.0 + ops.exp(ops.clamp(x, min=-20.0, max=20.0)))
+
+    def sigmoid(x):
+        ex = ops.exp(ops.clamp(x, min=-20.0, max=20.0))
+        return ex / (1.0 + ex)
+
+    def tanh(x):
+        e2x = ops.exp(ops.clamp(2.0 * x, min=-40.0, max=40.0))
+        return (e2x - 1.0) / (e2x + 1.0)
+
+    def dtanh(x, tanh_x):
+        """Derivative of tanh: 1 - tanh(x)^2. Reuses precomputed tanh_x."""
+        return 1.0 - tanh_x ** 2
+
+    L0 = t[0]
+    cP_raw = t[1]; aP_raw = t[2]
+    cD_raw = t[3]; aD_raw = t[4]
+    cR_raw = t[5]; aR_raw = t[6]
+
+    cP = softplus(cP_raw); aP = softplus(aP_raw)
+    cD = softplus(cD_raw); aD = softplus(aD_raw)
+    cR = softplus(cR_raw); aR = softplus(aR_raw)
+
+    sig_cP = sigmoid(cP_raw); sig_aP = sigmoid(aP_raw)
+    sig_cD = sigmoid(cD_raw); sig_aD = sigmoid(aD_raw)
+    sig_cR = sigmoid(cR_raw); sig_aR = sigmoid(aR_raw)
+
+    exp_P = ops.exp(-aP[:, None] * p[None, :])
+    exp_D = ops.exp(-aD[:, None] * s[None, :])
+    sp_diff = s[None, :] - p[None, :]
+    exp_R = ops.exp(-aR[:, None] * sp_diff)
+
+    term_P = cP[:, None] * exp_P
+    term_D = cD[:, None] * exp_D
+    term_R = cR[:, None] * exp_R
+
+    lr_opt = t[7][:, None] + t[8][:, None]*v[None, :] + t[9][:, None]*p[None, :] + t[10][:, None]*s[None, :]
+    dev_lr = u[None, :] - lr_opt
+    k_lr_raw = t[11]; a_lr_raw = t[12]
+    k_lr = softplus(k_lr_raw)
+    a_lr = tanh(a_lr_raw)
+    sig_k_lr = sigmoid(k_lr_raw)
+    dtanh_a_lr = dtanh(a_lr_raw, a_lr)  # 1 - tanh(a_lr_raw)^2
+
+    tanh_dev_lr = tanh(dev_lr)
+    dtanh_dev_lr = dtanh(dev_lr, tanh_dev_lr)
+    lr_pen = k_lr[:, None] * dev_lr**2 * (1.0 + a_lr[:, None] * tanh_dev_lr)
+
+    ns = u[None, :] - 0.5 * v[None, :]
+    ns_opt = t[13][:, None] + t[14][:, None]*p[None, :] + t[15][:, None]*s[None, :]
+    dev_ns = ns - ns_opt
+    k_ns_raw = t[16]; a_ns_raw = t[17]
+    k_ns = softplus(k_ns_raw)
+    a_ns = tanh(a_ns_raw)
+    sig_k_ns = sigmoid(k_ns_raw)
+    dtanh_a_ns = dtanh(a_ns_raw, a_ns)
+
+    tanh_dev_ns = tanh(dev_ns)
+    dtanh_dev_ns = dtanh(dev_ns, tanh_dev_ns)
+    ns_pen = k_ns[:, None] * dev_ns**2 * (1.0 + a_ns[:, None] * tanh_dev_ns)
+
+    delta0 = t[18]
+    k_dp_raw = t[19]
+    k_dp = softplus(k_dp_raw)
+    sig_k_dp = sigmoid(k_dp_raw)
+    dp_diff = sp_diff - delta0[:, None]
+    dp_pen = k_dp[:, None] * dp_diff**2
+
+    pred = L0[:, None] + term_P + term_D + term_R + lr_pen + ns_pen + dp_pen
+
+    # ---- Jacobian ----
+    ones_BM = pred * 0.0 + 1.0
+
+    # t[0] = L0
+    d_0 = ones_BM
+
+    # t[1] = cP (pre-softplus): d/dcP_raw = sig(cP_raw) * exp_P
+    d_1 = sig_cP[:, None] * exp_P
+
+    # t[2] = aP (pre-softplus): d/daP_raw = sig(aP_raw) * cP * (-p) * exp_P
+    d_2 = sig_aP[:, None] * cP[:, None] * (-p[None, :]) * exp_P
+
+    # t[3] = cD: d/dcD_raw = sig(cD_raw) * exp_D
+    d_3 = sig_cD[:, None] * exp_D
+
+    # t[4] = aD: d/daD_raw = sig(aD_raw) * cD * (-s) * exp_D
+    d_4 = sig_aD[:, None] * cD[:, None] * (-s[None, :]) * exp_D
+
+    # t[5] = cR: d/dcR_raw = sig(cR_raw) * exp_R
+    d_5 = sig_cR[:, None] * exp_R
+
+    # t[6] = aR: d/daR_raw = sig(aR_raw) * cR * (-(s-p)) * exp_R
+    d_6 = sig_aR[:, None] * cR[:, None] * (-sp_diff) * exp_R
+
+    # For lr_pen = k_lr * dev^2 * (1 + a_lr * tanh(dev))
+    # Let h(dev) = dev^2 * (1 + a_lr * tanh(dev))
+    # dh/d(dev) = 2*dev*(1 + a_lr*tanh(dev)) + dev^2*a_lr*(1-tanh(dev)^2)
+    bracket_lr = 1.0 + a_lr[:, None] * tanh_dev_lr
+    dh_ddev_lr = 2.0 * dev_lr * bracket_lr + dev_lr**2 * a_lr[:, None] * dtanh_dev_lr
+
+    # t[7] = phi0: d(dev)/d(phi0) = -1
+    d_7 = k_lr[:, None] * dh_ddev_lr * (-1.0)
+
+    # t[8] = phi_b: d(dev)/d(phi_b) = -v
+    d_8 = k_lr[:, None] * dh_ddev_lr * (-v[None, :])
+
+    # t[9] = phi_p: d(dev)/d(phi_p) = -p
+    d_9 = k_lr[:, None] * dh_ddev_lr * (-p[None, :])
+
+    # t[10] = phi_d: d(dev)/d(phi_d) = -s
+    d_10 = k_lr[:, None] * dh_ddev_lr * (-s[None, :])
+
+    # t[11] = k_lr (pre-softplus): d/dk_lr_raw = sig(k_lr_raw) * dev^2 * bracket_lr
+    d_11 = sig_k_lr[:, None] * dev_lr**2 * bracket_lr
+
+    # t[12] = a_lr (pre-tanh): d/da_lr_raw = dtanh(a_lr_raw) * k_lr * dev^2 * tanh(dev)
+    d_12 = dtanh_a_lr[:, None] * k_lr[:, None] * dev_lr**2 * tanh_dev_lr
+
+    # For ns_pen = k_ns * dev_ns^2 * (1 + a_ns * tanh(dev_ns))
+    bracket_ns = 1.0 + a_ns[:, None] * tanh_dev_ns
+    dh_ddev_ns = 2.0 * dev_ns * bracket_ns + dev_ns**2 * a_ns[:, None] * dtanh_dev_ns
+
+    # t[13] = psi0: d(dev_ns)/d(psi0) = -1
+    d_13 = k_ns[:, None] * dh_ddev_ns * (-1.0)
+
+    # t[14] = psi_p: d(dev_ns)/d(psi_p) = -p
+    d_14 = k_ns[:, None] * dh_ddev_ns * (-p[None, :])
+
+    # t[15] = psi_d: d(dev_ns)/d(psi_d) = -s
+    d_15 = k_ns[:, None] * dh_ddev_ns * (-s[None, :])
+
+    # t[16] = k_ns (pre-softplus): d/dk_ns_raw = sig(k_ns_raw) * dev_ns^2 * bracket_ns
+    d_16 = sig_k_ns[:, None] * dev_ns**2 * bracket_ns
+
+    # t[17] = a_ns (pre-tanh): d/da_ns_raw = dtanh(a_ns_raw) * k_ns * dev_ns^2 * tanh(dev_ns)
+    d_17 = dtanh_a_ns[:, None] * k_ns[:, None] * dev_ns**2 * tanh_dev_ns
+
+    # t[18] = delta0: dp_pen = k_dp * ((s-p) - delta0)^2
+    # d/ddelta0 = k_dp * 2*((s-p)-delta0) * (-1) = -2*k_dp*dp_diff
+    d_18 = -2.0 * k_dp[:, None] * dp_diff
+
+    # t[19] = k_dp (pre-softplus): d/dk_dp_raw = sig(k_dp_raw) * dp_diff^2
+    d_19 = sig_k_dp[:, None] * dp_diff**2
+
+    jac = ops.stack([d_0, d_1, d_2, d_3, d_4, d_5, d_6,
+                     d_7, d_8, d_9, d_10, d_11, d_12,
+                     d_13, d_14, d_15, d_16, d_17, d_18, d_19], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_9 (15p): Direct poly2(log10) without exp transform
+# x1=log10(lr), x2=log10(bsz), x3=log10(D), x4=log10(P)
+# loss = c0 + c1*x1 + ... + c14*x3*x4
+# theta: 15 coefficients
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    log10_inv = 1.0 / xp.log(lr * 0.0 + 10.0)
+    z0 = xp.log(lr) * log10_inv
+    z1 = xp.log(bsz) * log10_inv
+    z2 = xp.log(D) * log10_inv
+    z3 = xp.log(P) * log10_inv
+    ones = z0 * 0.0 + 1.0
+    feat_list = [
+        ones, z0, z1, z2, z3,
+        z0*z0, z1*z1, z2*z2, z3*z3,
+        z0*z1, z0*z2, z0*z3, z1*z2, z1*z3, z2*z3,
+    ]
+    if backend == "torch":
+        features = xp.stack(feat_list, dim=-1)
+        pred = xp.matmul(theta, features.T)
+    else:
+        features = xp.stack(feat_list, axis=-1)
+        pred = theta @ features.T
+
+    # Jacobian: pred = theta @ features.T (linear in theta)
+    # d pred / d theta_i = features[:, i], broadcast to (B, M)
+    # jac shape: (B, M, 15)
+    B = theta.shape[0]
+    M = features.shape[0]
+    # features is (M, 15), broadcast to (B, M, 15)
+    jac = xp.broadcast_to(features[None, :, :], (B, M, 15)) * 1.0
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_10 (18p): Direct poly2(log) + fixed-exponent power features
+# loss = poly2(log(lr), log(bsz), log(D), log(P)) + w_D*D^(-0.5) + w_P*P^(-0.5) + w_bsz*bsz^(-1)
+# theta: [c0..c14 (15 poly coeffs), w_D, w_P, w_bsz]
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    lr = ops.clamp_min(X[:, 0], _EPS)
+    bsz = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    P = ops.clamp_min(X[:, 3], _EPS)
+    z0 = xp.log(lr); z1 = xp.log(bsz); z2 = xp.log(D); z3 = xp.log(P)
+    ones = z0 * 0.0 + 1.0
+    feat_list = [
+        ones, z0, z1, z2, z3,
+        z0*z0, z1*z1, z2*z2, z3*z3,
+        z0*z1, z0*z2, z0*z3, z1*z2, z1*z3, z2*z3,
+    ]
+    if backend == "torch":
+        features = xp.stack(feat_list, dim=-1)
+        poly = xp.matmul(theta[:, :15], features.T)
+    else:
+        features = xp.stack(feat_list, axis=-1)
+        poly = theta[:, :15] @ features.T
+    w_D = theta[:, 15]
+    w_P = theta[:, 16]
+    w_bsz = theta[:, 17]
+
+    D_inv_sqrt = D[None, :] ** (-0.5)
+    P_inv_sqrt = P[None, :] ** (-0.5)
+    bsz_inv = 1.0 / bsz[None, :]
+
+    power_terms = (w_D[:, None] * D_inv_sqrt
+                   + w_P[:, None] * P_inv_sqrt
+                   + w_bsz[:, None] * bsz_inv)
+    pred = poly + power_terms
+
+    # ---- Jacobian ----
+    B = theta.shape[0]
+    M = features.shape[0]
+
+    # For c0..c14: d/dc_i = features[:, i], broadcast to (B, M)
+    # For w_D: d/dw_D = D^(-0.5)
+    # For w_P: d/dw_P = P^(-0.5)
+    # For w_bsz: d/dw_bsz = 1/bsz
+    ones_BM = pred * 0.0 + 1.0
+
+    partials = []
+    for i in range(15):
+        # features[:, i] has shape (M,), broadcast to (B, M)
+        partials.append(ones_BM * features[:, i][None, :])
+    partials.append(D_inv_sqrt * ones_BM)
+    partials.append(P_inv_sqrt * ones_BM)
+    partials.append(bsz_inv * ones_BM)
+
+    jac = ops.stack(partials, axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+PARAM_BOUNDS = {
+    # Dataset: lr∈[1.2e-4,0.022], bsz∈[16,4096], D∈[2e9,1e11], P∈[6e7,1.07e9]
+    # z0=log(lr)∈[-9,-4], z1=log(bsz)∈[3,8], z2=log(D)∈[21,25], z3=log(P)∈[18,21]
+    # lm_loss∈[2.08,3.70], log(loss)∈[0.73,1.31], Δlog(loss)≈0.58
+
+    # sl_1: 15p poly2 -> exp (NO clamp in model)
+    # [bias, z0, z1, z2, z3, z0^2, z1^2, z2^2, z3^2, z0z1, z0z2, z0z3, z1z2, z1z3, z2z3]
+    # poly output = log(loss) ∈ [0.73, 1.31]. Linear coeff bounds: |c|*Δz ≤ 0.58.
+    # Δz0=5.2,Δz1=5.5,Δz2=3.9,Δz3=2.9 → max|c_linear|≤0.2. Quad/cross: |c|*Δ(z^2) ≤ 0.58.
+    # Max Δ(z2^2)=183 → |c|≤0.003. Bias absorbs mean offsets: z2_mean*c2≈23*0.2=4.6 → bias∈(-15,15).
+    # Fit: bias=6.4, linear max=0.25, quad/cross max=0.013.
+    "sl_1": [(-15, 15)] + [(-0.35, 0.35)] * 4 + [(-0.025, 0.025)] * 10,
+
+    # sl_2: 26p softplus-penalty model (all softplus/tanh-clamped internally)
+    # [L_inf, Cp, ap, Cd, ad, Cdp, adp, k, u0, up, us, uv, v0, vp, vs,
+    #  cL0, cLp, cLs, cB0, cBp, cBs, rho, cLv, cBv, Cbb, abb]
+    # L_inf: irreducible loss ≈ 1.0. Cp/Cd/Cdp pre-softplus: fit found ~9-13 → allow up to 15.
+    # ap/ad/adp/abb: rate params, pre-softplus.
+    # k: mixing param for D/P interaction; k>3 risks overflow in exp(-adp*(s-k*p)) → restrict k≤3.
+    # u0: optimal log(lr) offset; v0: optimal log(bsz) offset.
+    # cL0,cB0: LR/BSZ curvature pre-softplus (fit found ~8-10); cLp,cBp,cLs,cBs,cLv,cBv: scaling.
+    # rho: correlation pre-tanh; Cbb/abb: batch-size penalty.
+    "sl_2": (
+        [(0, 3)]           # L_inf
+        + [(-5, 15), (-5, 5)] * 3  # Cp,ap, Cd,ad, Cdp,adp
+        + [(-5, 3)]        # k (k≤3 prevents exp overflow in Cdp term)
+        + [(-20, 2)]       # u0 (log(lr_opt)∈[-9,-4])
+        + [(-3, 3)] * 3    # up, us, uv
+        + [(0, 20)]        # v0 (log(bsz_opt)∈[3,8]; fit found 11.7)
+        + [(-3, 3)] * 2    # vp, vs
+        + [(-12, 12)] * 2  # cL0, cLp (fit found cL0=7.9, cLp=-9.2 near bounds)
+        + [(-12, 12)] * 2  # cLs, cB0 (fit found cB0=8.0 near upper bound)
+        + [(-12, 12)] * 2  # cBp, cBs
+        + [(-8, 8)]        # rho (pre-tanh; fit found -4.9 near lower -5)
+        + [(-12, 12)] * 2  # cLv, cBv
+        + [(-5, 15), (-5, 5)]  # Cbb, abb
+    ),
+
+    # sl_3: 24p Chinchilla + LR/BSZ penalties
+    # [E, A, alpha, B, beta, F, wN, wD,
+    #  C0, CN, CD, CB, mu0, muN, muD, muB, muND,
+    #  G0, GN, GD, nu0, nuN, nuD, nuND]
+    # E: irreducible loss (fit: 1.74). A/B: Chinchilla amplitudes (fit: 113, 3285).
+    # F: joint (N,D) amplitude (fit: 8.4e6, near upper 1e7 → expand to 2e7).
+    # C0,G0: LR/BSZ curvature (fit: 0.14, 0.16).
+    # mu0: log(lr_opt) intercept (fit: -7.4). nu0: log(bsz_opt) intercept (fit: 7.9).
+    "sl_3": (
+        [(0.5, 3)]         # E (fit: 1.74)
+        + [(0, 5e5), (0.05, 2)] * 2  # A,alpha, B,beta
+        + [(0, 2e7), (0.05, 2), (0.05, 2)]  # F, wN, wD
+        + [(0, 3), (-3, 3), (-3, 3), (-3, 3)]  # C0, CN, CD, CB
+        + [(-20, 5)]       # mu0 (log(lr_opt) intercept; fit: -7.4)
+        + [(-10, 3)] * 4   # muN, muD, muB, muND
+        + [(0, 3), (-3, 3), (-3, 3)]  # G0, GN, GD
+        + [(0, 15)]        # nu0 (log(bsz_opt) intercept; fit: 7.9)
+        + [(-3, 3)] * 3    # nuN, nuD, nuND
+    ),
+
+    # sl_4: 20p poly2+extras -> exp (NO clamp in model)
+    # [15 poly coeffs, z2-z3, 1/bsz, 1/bsz^2, 1/D, 1/P]
+    # Same poly as sl_1 for first 15 params. Extra features added inside the exponent.
+    # 1/bsz∈[2.4e-4,0.0625]: |w|*0.062 ≤ 0.58 → |w|≤9.3; fit: -0.031.
+    # 1/bsz^2∈[6e-8,3.9e-3]: |w|*3.9e-3 ≤ 0.58 → |w|≤149; fit: 3.08.
+    # 1/D∈[1e-11,5e-10]: |w|*5e-10 ≤ 0.58 → |w|≤1.2e9; fit: ~0.
+    # 1/P∈[9.3e-10,1.67e-8]: |w|*1.67e-8 ≤ 0.58 → |w|≤3.5e7; fit: ~0.
+    "sl_4": (
+        [(-15, 15)] + [(-0.35, 0.35)] * 4 + [(-0.025, 0.025)] * 10
+        + [(-0.3, 0.3)]    # z2-z3 = log(D/P); fit: -0.093
+        + [(-10, 10)]      # 1/bsz; fit: -0.031
+        + [(-200, 200)]    # 1/bsz^2; fit: 3.08
+        + [(-1.5e9, 1.5e9)]  # 1/D; fit: ~0
+        + [(-5e7, 5e7)]    # 1/P; fit: ~0
+    ),
+
+    # sl_5: 19p Chinchilla + exp-decay + LR penalty
+    # [L0, AN, aN, AD, aD, AB, aB, clr0, u0, kb, kn, kd, wb, wn, ws, AR, aR, AX, aX]
+    # AN*exp(-aN*n): n=log(P)∈[18,21]; aN~0.26 → AN~110 for 0.5 contribution.
+    # AD*exp(-aD*s): s=log(D)∈[21,25]; aD~0.52 → AD~7200 for 0.5 contribution.
+    # AB*exp(-aB*v): v=log(bsz)∈[3,8]; contribution~AB*0.2; AB~1 at optimal.
+    # AX*exp(-aX*(s-v)): s-v∈[14,22]; aX~0.49 → AX~535 for visible contribution.
+    # clr0: LR curvature amplitude; u0: log(lr_opt) center.
+    "sl_5": (
+        [(0, 3)]           # L0 (fit: 1.5)
+        + [(0, 2e4), (0.01, 2)]  # AN, aN (fit: 110, 0.26)
+        + [(0, 2e4), (0.01, 2)]  # AD, aD (fit: 7202, 0.52)
+        + [(0, 20), (0.01, 2)]   # AB, aB (fit: 1.03, 0.40)
+        + [(0, 200)]       # clr0 (fit: 74.1)
+        + [(-12, 3)]       # u0 (log(lr_opt) center; fit: -1.96)
+        + [(-2, 2)] * 3    # kb, kn, kd
+        + [(-2, 2)] * 3    # wb, wn, ws
+        + [(0, 5), (0, 2)]     # AR, aR (fit: 0.27, 0.11)
+        + [(0, 2000), (0, 2)]  # AX, aX (fit: 535, 0.49)
+    ),
+
+    # sl_6: 14p L_inf + exp(poly13), HAS clamp [-50,50] on exponent
+    # [L_inf, w0, w_d, w_p, w_dp, w_lr, w_lr2, w_bsz, w_bsz2, w_lrbsz, w_lrD, w_lrP, w_bszD, w_bszP]
+    # exp(poly) = lm_loss - L_inf ∈ (0, 1.7]; log of that ≤ 0.53. Same scale analysis as sl_1.
+    # w_lr,w_bsz: up to 0.47 (z0/z1 range 5.2/5.5); w_dp,cross: small (quad range ~143→|c|≤0.004).
+    # Fit (DE): L_inf=1.82, w0=-0.74, w_d=0.15, w_p=0.31, w_dp=-0.011, w_lr=0.47, w_lr2=0.052,
+    #   w_bsz=0.36, w_bsz2=0.034, w_lrbsz=-0.029, w_lrD=-0.007, w_lrP=0.027, w_bszD=-0.033, w_bszP=-0.007
+    "sl_6": (
+        [(0, 3)]           # L_inf
+        + [(-8, 8)]        # w0 (bias of inner poly)
+        + [(-0.5, 0.5)] * 2   # w_d, w_p (z2,z3 linear)
+        + [(-0.025, 0.025)]   # w_dp (z2*z3 cross; Δ=143)
+        + [(-0.6, 0.6)] * 2   # w_lr, w_lr2 (z0 linear and quad)
+        + [(-0.5, 0.5)] * 2   # w_bsz, w_bsz2 (z1 linear and quad)
+        + [(-0.04, 0.04)]     # w_lrbsz (z0*z1 cross; Δ=62.5)
+        + [(-0.02, 0.02)]     # w_lrD (z0*z2; Δ=139)
+        + [(-0.04, 0.04)]     # w_lrP (z0*z3; Δ=114)
+        + [(-0.05, 0.05)]     # w_bszD (z1*z2; Δ=151)
+        + [(-0.02, 0.02)]     # w_bszP (z1*z3; Δ=120)
+    ),
+
+    # sl_7: 31p E + 2*exp(poly2), HAS clamp [-50,50] on each exponent
+    # [E, w1[0..14], w2[0..14]] — each poly2 has same structure as sl_1
+    # Each exp term ≤ lm_loss-E ≤ 1.7; same coefficient analysis as sl_1.
+    # Quad/cross bounds expanded to (-0.03,0.03) since some coefficients found near ±0.02.
+    # Fit: E=1.75, w1_bias=4.26, w2_bias=3.17; quad coeffs up to ±0.02.
+    "sl_7": (
+        [(0, 2.5)]         # E
+        + [(-15, 15)] + [(-0.35, 0.35)] * 4 + [(-0.03, 0.03)] * 10  # w1
+        + [(-15, 15)] + [(-0.35, 0.35)] * 4 + [(-0.03, 0.03)] * 10  # w2
+    ),
+
+    # sl_8: 20p softplus/tanh model (all internally clamped via softplus/tanh)
+    # [L0, cP, aP, cD, aD, cR, aR, phi0, phi_b, phi_p, phi_d,
+    #  k_lr, a_lr, psi0, psi_p, psi_d, k_ns, a_ns, delta0, k_dp]
+    # All cP,cD,cR,k_lr,k_ns,k_dp pre-softplus; aP,aD,aR pre-softplus (positive rates).
+    # phi0: log(lr_opt) intercept (fit: -14.1); psi0: log(bsz_opt) intercept (fit: -1.4).
+    # delta0: (log(D/P)) offset; s-p∈[0.6,6.1]; fit: 6.8.
+    # All fit values within bounds; no expansion needed.
+    "sl_8": (
+        [(-1, 3)]          # L0 (fit: -0.44)
+        + [(-3, 12), (-5, 5)] * 3  # cP,aP, cD,aD, cR,aR (pre-softplus)
+        + [(-20, 3)]       # phi0 (fit: -14.1)
+        + [(-5, 5)] * 3    # phi_b, phi_p, phi_d
+        + [(-5, 10)]       # k_lr (pre-softplus; fit: -4.9)
+        + [(-5, 5)]        # a_lr (pre-tanh; fit: 3.5)
+        + [(-15, 5)]       # psi0 (log(bsz_opt) intercept; fit: -1.4)
+        + [(-5, 5)] * 2    # psi_p, psi_d
+        + [(-5, 10)]       # k_ns (pre-softplus; fit: 0.74)
+        + [(-5, 5)]        # a_ns (pre-tanh; fit: 4.2)
+        + [(-5, 10)]       # delta0 (s-p offset; fit: 6.8)
+        + [(-5, 10)]       # k_dp (pre-softplus; fit: -4.9)
+    ),
+
+    # sl_9: 15p direct poly2(log10), no exp transform
+    # [c0, c_lr, c_bsz, c_D, c_P, c_lr2, c_bsz2, c_D2, c_P2, c_lr_bsz..c_D_P]
+    # log10: z0∈[-3.91,-1.66], z1∈[1.20,3.61], z2∈[9.30,11.0], z3∈[7.78,9.03]
+    # loss ∈ [2.08, 3.70], Δ=1.62. Linear: |c|*Δz ≤ 1.62 → |c_D|≤1.62/1.7=0.95.
+    # Quad: |c|*Δ(z2^2)=|c|*34.5 ≤ 1.62 → |c|≤0.047. Cross: Δ(z2*z3)=27 → |c|≤0.06.
+    # Bias must absorb z3 contribution at mean: c_P*z3_mean≈-0.31*8.4=-2.6. Fit: bias=16.09.
+    # Fit: c0=16.09, c_D=-2.06, c_P=-0.31, quad max=0.14, cross max=0.13.
+    "sl_9": (
+        [(-5, 30)]         # c0 (bias; fit: 16.09)
+        + [(-4, 4)] * 4    # c_lr, c_bsz, c_D, c_P (fit max: |c_D|=2.06)
+        + [(-0.3, 0.3)] * 10  # quad + cross coefficients (fit max: 0.14)
+    ),
+
+    # sl_10: 18p direct poly2(log) + power features, no exp
+    # [c0..c14, w_D, w_P, w_bsz]  (natural log, not log10)
+    # Natural log: z0∈[-9,-4], z1∈[3,8], z2∈[21,25], z3∈[18,21]
+    # Δz3=2.9 → max|c_P|≤1.62/2.9=0.56. Quad: Δ(z2^2)=183 → |c|≤0.009.
+    # Bias absorbs z3 contribution: at mean z3=19.3, c3=-1.34 → 19.3*(-1.34)=-25.9; bias∈(-5,35).
+    # Power: D^(-0.5)∈[3.2e-6,2.2e-5], Δ=1.92e-5 → |w_D|≤1.62/1.92e-5=84375; fit: 1.68e4.
+    # P^(-0.5)∈[3.1e-5,1.3e-4], Δ=9.9e-5 → |w_P|≤1.62/9.9e-5=16364; fit: -3469.
+    # 1/bsz∈[2.4e-4,0.0625], Δ=0.062 → |w_bsz|≤26; fit: 1.0.
+    "sl_10": (
+        [(-5, 35)]         # c0 (bias; fit: 16.27)
+        + [(-2, 2)] * 4    # c_lr, c_bsz, c_D, c_P (fit: c_P=-1.34)
+        + [(-0.1, 0.1)] * 10  # quad + cross (fit max: 0.044)
+        + [(-5e4, 5e4)]    # w_D (D^-0.5; fit: 1.68e4)
+        + [(-2e4, 2e4)]    # w_P (P^-0.5; fit: -3469)
+        + [(-15, 15)]      # w_bsz (1/bsz; fit: 1.0)
+    ),
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 15, "sl_2": 26, "sl_3": 24, "sl_4": 20, "sl_5": 19,
+    "sl_6": 14, "sl_7": 31, "sl_8": 20, "sl_9": 15, "sl_10": 18,
+}

lr_bsz_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed6c33d124562015805d3715f9f01a58e5d27befcd63d30be23a94eedc9caa68
+size 3944

lr_bsz_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e8bf513e7c7da2b82e3d324c19643256e3f5cc5770aa4d0dcbc0aa3c38768e5
+size 35166

moe_scaling_law/laws.py

@@ -0,0 +1,622 @@
+"""Scaling laws for Mixture-of-Experts models.
+
+X columns: [num_experts (E), dense_parameter_count (N)]
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+
+
+# Scaling law 1 (4 params):
+#   L_inf + B / (N^alpha * E^beta)
+# theta: [L_inf, B, alpha, beta]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    L_inf = theta[:, 0]
+    B = theta[:, 1]
+    alpha = theta[:, 2]
+    beta = theta[:, 3]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    denom = (N[None, :] ** alpha[:, None]) * (E[None, :] ** beta[:, None])
+    denom = ops.clamp_min(denom, _EPS)
+
+    frac = B[:, None] / denom  # B / (N^alpha * E^beta)
+    pred = L_inf[:, None] + frac
+
+    ones = pred * 0.0 + 1.0
+    # d/d(L_inf) = 1
+    d_L_inf = ones
+    # d/d(B) = 1 / denom
+    d_B = frac / B[:, None]  # = 1/denom, but reuse frac
+    # d/d(alpha) = -B / denom * log(N) = -frac * log(N)
+    d_alpha = -frac * logN[None, :]
+    # d/d(beta) = -frac * log(E)
+    d_beta = -frac * logE[None, :]
+
+    jac = ops.stack([d_L_inf, d_B, d_alpha, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 2 (5 params):
+#   L + K * (N^alpha * E^beta)^(-gamma)
+# theta: [L, K, alpha, beta, gamma]
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    L = theta[:, 0]
+    K = theta[:, 1]
+    alpha = theta[:, 2]
+    beta = theta[:, 3]
+    gamma = theta[:, 4]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    base = (N[None, :] ** alpha[:, None]) * (E[None, :] ** beta[:, None])
+    base = ops.clamp_min(base, _EPS)
+
+    power_term = base ** (-gamma[:, None])  # (N^a * E^b)^(-g)
+    term = K[:, None] * power_term
+    pred = L[:, None] + term
+
+    ones = pred * 0.0 + 1.0
+    # log(base) = alpha*log(N) + beta*log(E)
+    log_base = alpha[:, None] * logN[None, :] + beta[:, None] * logE[None, :]
+
+    # d/dL = 1
+    d_L = ones
+    # d/dK = power_term
+    d_K = power_term
+    # d/d(alpha) = K * power_term * (-gamma) * log(N) = term * (-gamma) * log(N)
+    d_alpha = term * (-gamma[:, None]) * logN[None, :]
+    # d/d(beta) = term * (-gamma) * log(E)
+    d_beta = term * (-gamma[:, None]) * logE[None, :]
+    # d/d(gamma) = K * power_term * (-log(base)) = term * (-log_base)
+    d_gamma = term * (-log_base)
+
+    jac = ops.stack([d_L, d_K, d_alpha, d_beta, d_gamma], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 3 (6 params):
+#   A * P^alpha / (1 + B * E^beta) + C * P^(alpha*0.6) + D
+#   (gamma = alpha * 0.6 is hard-coded)
+# theta: [A, alpha, B, beta, C, D]
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    A = theta[:, 0]
+    alpha = theta[:, 1]
+    B = theta[:, 2]
+    beta = theta[:, 3]
+    C = theta[:, 4]
+    D = theta[:, 5]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    N_alpha = N[None, :] ** alpha[:, None]          # (B_t, M)
+    E_beta = E[None, :] ** beta[:, None]             # (B_t, M)
+    denom = 1.0 + B[:, None] * E_beta               # (B_t, M)
+    efficiency = A[:, None] * N_alpha / denom        # term1
+
+    gamma_val = alpha[:, None] * 0.6
+    N_gamma = N[None, :] ** gamma_val                # (B_t, M)
+    param_scale = C[:, None] * N_gamma               # term2
+
+    pred = efficiency + param_scale + D[:, None]
+
+    ones = pred * 0.0 + 1.0
+
+    # d/dA = N^alpha / denom
+    d_A = N_alpha / denom
+    # d/d(alpha):
+    #   d(efficiency)/d(alpha) = A * N^alpha * log(N) / denom = efficiency * log(N)
+    #   d(param_scale)/d(alpha) = C * N^(alpha*0.6) * 0.6 * log(N) = param_scale * 0.6 * log(N)
+    d_alpha = efficiency * logN[None, :] + param_scale * 0.6 * logN[None, :]
+    # d/dB = -A * N^alpha * E^beta / denom^2 = -efficiency * E^beta / denom
+    d_B = -efficiency * E_beta / denom
+    # d/d(beta) = -A * N^alpha * B * E^beta * log(E) / denom^2
+    #           = -efficiency * B[:, None] * E_beta * log(E) / denom
+    d_beta = -efficiency * B[:, None] * E_beta * logE[None, :] / denom
+    # d/dC = N^(alpha*0.6)
+    d_C = N_gamma
+    # d/dD = 1
+    d_D = ones
+
+    jac = ops.stack([d_A, d_alpha, d_B, d_beta, d_C, d_D], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 4 (6 params):
+#   a / (N^alpha * (1 + b*E)^gamma) + c + d*(log(N) - 0.4*log(1+E))
+# theta: [a, alpha, b, gamma, c, d]
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], 1.0)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    a = theta[:, 0]
+    alpha = theta[:, 1]
+    b = theta[:, 2]
+    gamma = theta[:, 3]
+    c = theta[:, 4]
+    d = theta[:, 5]
+
+    logN = xp.log(N)
+    log1E = xp.log(1.0 + E)
+
+    N_alpha = N[None, :] ** alpha[:, None]
+    bE_term = 1.0 + b[:, None] * E[None, :]         # (B_t, M)
+    bE_term_safe = ops.clamp_min(bE_term, _EPS)
+    expert_sat = bE_term_safe ** gamma[:, None]
+    expert_sat = ops.clamp_min(expert_sat, _EPS)
+
+    main = a[:, None] / (N_alpha * expert_sat)       # a / (N^alpha * (1+bE)^gamma)
+
+    log_correction = d[:, None] * (logN[None, :] - 0.4 * log1E[None, :])
+
+    pred = main + c[:, None] + log_correction
+
+    ones = pred * 0.0 + 1.0
+
+    # d/da = 1 / (N^alpha * expert_sat) = main / a[:, None]
+    d_a = main / a[:, None]
+    # d/d(alpha) = -main * log(N)
+    d_alpha = -main * logN[None, :]
+    # d/db = -a * gamma * E * (1+bE)^(gamma-1) / (N^alpha * (1+bE)^(2*gamma))
+    #       = -main * gamma * E / (1+bE)
+    #   Since main = a / (N^a * (1+bE)^g), and d/db of (1+bE)^g = g*E*(1+bE)^(g-1)
+    #   d(main)/db = -a * g * E * (1+bE)^(g-1) / (N^a * ((1+bE)^g)^2)
+    #   but (1+bE)^(g-1) / ((1+bE)^g)^2 = 1/((1+bE)^(g+1))
+    #   Simpler: main = a * (N^alpha * (1+bE)^gamma)^(-1)
+    #   d/db = -main * gamma * E / (1+bE)
+    d_b = -main * gamma[:, None] * E[None, :] / bE_term_safe
+    # d/d(gamma) = -main * log(1+bE)
+    log_bE_term = xp.log(ops.clamp_min(bE_term_safe, _EPS))
+    d_gamma = -main * log_bE_term
+    # d/dc = 1
+    d_c = ones
+    # d/dd = log(N) - 0.4*log(1+E)
+    d_d = logN[None, :] - 0.4 * log1E[None, :]
+    # broadcast d_d to (B_t, M)
+    d_d = d_d + ones * 0.0
+
+    jac = ops.stack([d_a, d_alpha, d_b, d_gamma, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 5 (6 params):
+#   p0 + exp(p1 + p2*log(E) + p3*log(P) + p4*log(E)*log(P)) + p5*log(E)
+# theta: [p0, p1, p2, p3, p4, p5]
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], 1.0)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    p0 = theta[:, 0]
+    p1 = theta[:, 1]
+    p2 = theta[:, 2]
+    p3 = theta[:, 3]
+    p4 = theta[:, 4]
+    p5 = theta[:, 5]
+
+    log_E = xp.log(E)[None, :]   # (1, M)
+    log_N = xp.log(N)[None, :]   # (1, M)
+
+    exponent = (
+        p1[:, None]
+        + p2[:, None] * log_E
+        + p3[:, None] * log_N
+        + p4[:, None] * log_E * log_N
+    )
+    # Clip exponent for numerical safety
+    exponent = ops.clamp(exponent, min=-50.0, max=50.0)
+
+    exp_val = ops.exp(exponent)   # (B_t, M)
+
+    pred = p0[:, None] + exp_val + p5[:, None] * log_E
+
+    ones = pred * 0.0 + 1.0
+
+    # d/d(p0) = 1
+    d_p0 = ones
+    # d/d(p1) = exp_val * 1 = exp_val
+    d_p1 = exp_val
+    # d/d(p2) = exp_val * log_E
+    d_p2 = exp_val * log_E
+    # d/d(p3) = exp_val * log_N
+    d_p3 = exp_val * log_N
+    # d/d(p4) = exp_val * log_E * log_N
+    d_p4 = exp_val * log_E * log_N
+    # d/d(p5) = log_E
+    d_p5 = log_E + ones * 0.0  # broadcast to (B_t, M)
+
+    jac = ops.stack([d_p0, d_p1, d_p2, d_p3, d_p4, d_p5], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 6 (6 params):
+#   a * N^(-b) * (1 + c*E^(-d)) + e + f/(E * N^0.05)
+# theta: [a, b, c, d, e, f]
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], 1.0)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    a = theta[:, 0]
+    b = theta[:, 1]
+    c = theta[:, 2]
+    d = theta[:, 3]
+    e = theta[:, 4]
+    f = theta[:, 5]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    N_neg_b = N[None, :] ** (-b[:, None])            # (B_t, M)
+    E_neg_d = E[None, :] ** (-d[:, None])             # (B_t, M)
+    expert_mod = 1.0 + c[:, None] * E_neg_d           # (B_t, M)
+    base = a[:, None] * N_neg_b                       # a * N^(-b)
+    term1 = base * expert_mod                         # a * N^(-b) * (1 + c*E^(-d))
+    interaction = f[:, None] / (E[None, :] * (N[None, :] ** 0.05))  # f/(E*N^0.05)
+
+    pred = term1 + e[:, None] + interaction
+
+    ones = pred * 0.0 + 1.0
+
+    # d/da = N^(-b) * expert_mod
+    d_a = N_neg_b * expert_mod
+    # d/db = a * N^(-b) * (-log(N)) * expert_mod = -term1 * log(N)
+    d_b = -term1 * logN[None, :]
+    # d/dc = a * N^(-b) * E^(-d) = base * E_neg_d
+    d_c = base * E_neg_d
+    # d/dd = a * N^(-b) * c * E^(-d) * (-log(E)) = -base * c[:, None] * E_neg_d * log(E)
+    d_d = -base * c[:, None] * E_neg_d * logE[None, :]
+    # d/de = 1
+    d_e = ones
+    # d/df = 1 / (E * N^0.05)
+    d_f = 1.0 / (E[None, :] * (N[None, :] ** 0.05))
+    d_f = d_f + ones * 0.0  # ensure broadcast
+
+    jac = ops.stack([d_a, d_b, d_c, d_d, d_e, d_f], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 7 (6 params):
+#   p0 * E^p1 * P^p2 + p3 * P^p4 + p5
+#   (multiplicative + additive power law)
+# theta: [p0, p1, p2, p3, p4, p5]
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    p0 = theta[:, 0]
+    p1 = theta[:, 1]
+    p2 = theta[:, 2]
+    p3 = theta[:, 3]
+    p4 = theta[:, 4]
+    p5 = theta[:, 5]
+
+    logE = xp.log(ops.clamp_min(E, _EPS))
+    logN = xp.log(ops.clamp_min(N, _EPS))
+
+    E_p1 = E[None, :] ** p1[:, None]
+    N_p2 = N[None, :] ** p2[:, None]
+    N_p4 = N[None, :] ** p4[:, None]
+
+    term1 = p0[:, None] * E_p1 * N_p2          # p0 * E^p1 * N^p2
+    term2 = p3[:, None] * N_p4                  # p3 * N^p4
+
+    pred = term1 + term2 + p5[:, None]
+
+    ones = pred * 0.0 + 1.0
+
+    # d/d(p0) = E^p1 * N^p2
+    d_p0 = E_p1 * N_p2
+    # d/d(p1) = term1 * log(E)
+    d_p1 = term1 * logE[None, :]
+    # d/d(p2) = term1 * log(N)
+    d_p2 = term1 * logN[None, :]
+    # d/d(p3) = N^p4
+    d_p3 = N_p4
+    # d/d(p4) = term2 * log(N)
+    d_p4 = term2 * logN[None, :]
+    # d/d(p5) = 1
+    d_p5 = ones
+
+    jac = ops.stack([d_p0, d_p1, d_p2, d_p3, d_p4, d_p5], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 8 (4 params):
+#   a * N^b * E^c + d
+# theta: [a, b, c, d]
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    a = theta[:, 0]
+    b = theta[:, 1]
+    c = theta[:, 2]
+    d = theta[:, 3]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    N_b = N[None, :] ** b[:, None]
+    E_c = E[None, :] ** c[:, None]
+    term = a[:, None] * N_b * E_c               # a * N^b * E^c
+
+    pred = term + d[:, None]
+
+    ones = pred * 0.0 + 1.0
+
+    # d/da = N^b * E^c
+    d_a = N_b * E_c
+    # d/db = term * log(N)
+    d_b = term * logN[None, :]
+    # d/dc = term * log(E)
+    d_c = term * logE[None, :]
+    # d/dd = 1
+    d_d = ones
+
+    jac = ops.stack([d_a, d_b, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 9 (4 params):
+#   c0 + A * (N * E^g)^(-a)
+# theta: [c0, A, g, a]
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    c0 = theta[:, 0]
+    A = theta[:, 1]
+    g = theta[:, 2]
+    a = theta[:, 3]
+
+    logN = xp.log(ops.clamp_min(N, _EPS))
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    N_eff = N[None, :] * (E[None, :] ** g[:, None])
+    N_eff = ops.clamp_min(N_eff, _EPS)
+
+    power_term = N_eff ** (-a[:, None])          # (N*E^g)^(-a)
+    term = A[:, None] * power_term
+
+    pred = c0[:, None] + term
+
+    ones = pred * 0.0 + 1.0
+
+    # log(N_eff) = log(N) + g*log(E)
+    log_N_eff = logN[None, :] + g[:, None] * logE[None, :]
+
+    # d/d(c0) = 1
+    d_c0 = ones
+    # d/d(A) = power_term
+    d_A = power_term
+    # d/d(g) = A * power_term * (-a) * log(E) = term * (-a) * log(E)
+    #   since d/dg of N_eff^(-a) = (-a) * N_eff^(-a) * d(log N_eff)/dg
+    #   and d(log N_eff)/dg = log(E)
+    d_g = term * (-a[:, None]) * logE[None, :]
+    # d/d(a) = A * power_term * (-log(N_eff)) = term * (-log_N_eff)
+    d_a = term * (-log_N_eff)
+
+    jac = ops.stack([d_c0, d_A, d_g, d_a], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# Scaling law 10 (6 params):
+#   bias + A * (N/1e9)^(-alpha) * ((1 + B*E^gamma) / (1 + B))^(-beta)
+# theta: [bias, A, alpha, B, gamma, beta]
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    E = ops.clamp_min(X[:, 0], _EPS)
+    N = ops.clamp_min(X[:, 1], _EPS)
+
+    bias = theta[:, 0]
+    A = theta[:, 1]
+    alpha = theta[:, 2]
+    B = theta[:, 3]
+    gamma = theta[:, 4]
+    beta = theta[:, 5]
+
+    logE = xp.log(ops.clamp_min(E, _EPS))
+
+    N_scaled = N[None, :] / 1e9
+    N_scaled = ops.clamp_min(N_scaled, _EPS)
+    logN_scaled = xp.log(ops.clamp_min(N_scaled, _EPS))
+
+    term_N = N_scaled ** (-alpha[:, None])           # (N/1e9)^(-alpha)
+
+    E_gamma = E[None, :] ** gamma[:, None]
+    expert_num = 1.0 + B[:, None] * E_gamma          # 1 + B*E^gamma
+    expert_den = ops.clamp_min(1.0 + B[:, None], _EPS)  # 1 + B
+    ratio = expert_num / expert_den                   # (1 + B*E^g) / (1 + B)
+    ratio_safe = ops.clamp_min(ratio, _EPS)
+    term_E = ratio_safe ** (-beta[:, None])           # ratio^(-beta)
+
+    full_term = A[:, None] * term_N * term_E          # A * term_N * term_E
+    pred = bias[:, None] + full_term
+
+    ones = pred * 0.0 + 1.0
+
+    # d/d(bias) = 1
+    d_bias = ones
+    # d/d(A) = term_N * term_E
+    d_A = term_N * term_E
+    # d/d(alpha) = full_term * (-log(N_scaled))
+    d_alpha = full_term * (-logN_scaled)
+    # d/d(B):
+    #   ratio = (1 + B*E^g) / (1 + B)
+    #   d(ratio)/dB = (E^g * (1+B) - (1+B*E^g)) / (1+B)^2
+    #               = (E^g - 1) / (1+B)^2
+    #   d(term_E)/dB = (-beta) * ratio^(-beta-1) * d(ratio)/dB
+    #   d(full_term)/dB = A * term_N * d(term_E)/dB
+    #                   = full_term * (-beta) / ratio * (E^g - 1) / (1+B)^2
+    #   But ratio = expert_num / expert_den, so 1/ratio = expert_den / expert_num
+    #   = full_term * (-beta) * (E^g - 1) / (expert_num * (1+B))
+    #   Alternatively:  full_term * (-beta) * (E_gamma - 1.0) / (expert_num * expert_den)
+    #   Wait let me redo: expert_den = 1+B
+    #   d(ratio)/dB = (E^g - 1) / expert_den^2
+    #   d(term_E)/dB = (-beta) * ratio^(-beta-1) * (E^g - 1) / expert_den^2
+    #   = (-beta) * ratio^(-beta) * (1/ratio) * (E^g - 1) / expert_den^2
+    #   = (-beta) * term_E * (expert_den / expert_num) * (E^g - 1) / expert_den^2
+    #   = (-beta) * term_E * (E^g - 1) / (expert_num * expert_den)
+    #   So: d_B = A * term_N * (-beta) * term_E * (E^g - 1) / (expert_num * expert_den)
+    #          = full_term * (-beta) * (E_gamma - 1.0) / (expert_num * expert_den)
+    d_B = full_term * (-beta[:, None]) * (E_gamma - 1.0) / (ops.clamp_min(expert_num, _EPS) * expert_den)
+
+    # d/d(gamma):
+    #   d(ratio)/d(gamma) = B * E^g * log(E) / (1+B)
+    #   d(term_E)/d(gamma) = (-beta) * ratio^(-beta-1) * B * E^g * log(E) / expert_den
+    #   = (-beta) * term_E * (1/ratio) * B * E^g * log(E) / expert_den
+    #   = (-beta) * term_E * expert_den / expert_num * B * E^g * log(E) / expert_den
+    #   = (-beta) * term_E * B * E^g * log(E) / expert_num
+    #   d_gamma = full_term * (-beta) * B * E^g * log(E) / expert_num
+    d_gamma = full_term * (-beta[:, None]) * B[:, None] * E_gamma * logE[None, :] / ops.clamp_min(expert_num, _EPS)
+
+    # d/d(beta) = A * term_N * d(term_E)/d(beta)
+    #   term_E = ratio^(-beta)
+    #   d/d(beta) = ratio^(-beta) * (-log(ratio)) = term_E * (-log(ratio))
+    #   d_beta = full_term * (-log(ratio))
+    log_ratio = xp.log(ops.clamp_min(ratio_safe, _EPS))
+    d_beta = full_term * (-log_ratio)
+
+    jac = ops.stack([d_bias, d_A, d_alpha, d_B, d_gamma, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+PARAM_BOUNDS = {
+    # Dataset: E ∈ {1,2,...,512}, log(E) ∈ [0,6.24]; N ∈ [1.65e7,1.31e9]; loss ∈ [2.0,3.16]
+    # sl_1: [L_inf, B, alpha, beta] — L_inf + B / (N^alpha * E^beta)
+    # Fit: L_inf≈1.55, B≈38, alpha≈0.19, beta≈0.07
+    "sl_1": [(0, 3), (0.1, 500), (0, 1.5), (-0.5, 1.5)],
+    # sl_2: [L, K, alpha, beta, gamma] — L + K*(N^alpha * E^beta)^(-gamma)
+    # Fit: L≈1.55, K≈38, alpha≈0.88, beta≈0.32, gamma≈0.22; alpha*gamma≈0.19, beta*gamma≈0.07
+    "sl_2": [(0, 3), (0, 500), (0, 2), (0, 2), (0, 2)],
+    # sl_3: [A, alpha, B, beta, C, D] — A*N^alpha/(1+B*E^beta) + C*N^(alpha*0.6) + D
+    # Fit: A≈28, alpha≈-0.22, B≈0.12, beta≈0.64, C≈10.7, D≈1.32
+    # alpha<0 required: N^alpha decreases loss as N grows
+    "sl_3": [(0, 5e3), (-1.5, 0), (0, 20), (0, 2), (-1e4, 1e4), (-5, 5)],
+    # sl_4: [a, alpha, b, gamma, c, d] — a/(N^alpha*(1+b*E)^gamma) + c + d*(logN-0.4*log(1+E))
+    # Fit: a≈36, alpha≈0.19, b≈0.39, gamma≈0.12, c≈2.21, d≈-0.03
+    "sl_4": [(0.1, 500), (0, 1.5), (0, 20), (0, 1.5), (-5, 5), (-1, 1)],
+    # sl_5: [p0,p1,p2,p3,p4,p5] — p0 + exp(p1+p2*logE+p3*logN+p4*logE*logN) + p5*logE
+    # Fit: p0≈1.59, p1≈3.80, p2≈-0.24, p3≈-0.20, p4≈0.013, p5≈-0.07
+    # Exponent clamped to [-50,50] in model; p3*logN_max≈-0.2*21=-4.2 keeps p1<10 safe
+    "sl_5": [(0, 3), (-5, 10), (-1, 1), (-1, 1), (-0.1, 0.1), (-1, 1)],
+    # sl_6: [a, b, c, d, e, f] — a*N^(-b)*(1+c*E^(-d)) + e + f/(E*N^0.05)
+    # Fit: a≈10.8, b≈0.17, c≈2.03, d≈0.14, e≈1.49, f≈-0.41
+    "sl_6": [(0, 200), (0, 1.5), (-5, 20), (-0.5, 2), (-5, 5), (-20, 20)],
+    # sl_7: [p0,p1,p2,p3,p4,p5] — p0*E^p1*N^p2 + p3*N^p4 + p5
+    # Fit degenerate: p0≈6089, p1≈0, p2≈p4≈-0.215, p3≈-6060, p5≈1.51
+    # True behavior: (p0+p3)*N^p2 + p5 ≈ 29*N^(-0.215) + 1.5 (p1≈0 kills E-dependence)
+    "sl_7": [(-500, 500), (-1, 0.5), (-1.5, 0.5), (-500, 500), (-1.5, 0.5), (-5, 5)],
+    # sl_8: [a, b, c, d] — a*N^b * E^c + d
+    # Fit: a≈37.9, b≈-0.19, c≈-0.07, d≈1.55
+    "sl_8": [(0, 500), (-1.5, 0.5), (-1.5, 0.5), (0, 3)],
+    # sl_9: [c0, A, g, a] — c0 + A*(N*E^g)^(-a)
+    # Fit: c0≈1.55, A≈37.9, g≈0.37, a≈0.19
+    "sl_9": [(0, 3), (0, 500), (-1, 2), (0, 2)],
+    # sl_10: [bias, A, alpha, B, gamma, beta] — bias + A*(N/1e9)^(-alpha)*((1+B*E^gamma)/(1+B))^(-beta)
+    # Fit: bias≈1.59, A≈0.70, alpha≈0.20, B≈0.1 (near 0=degenerate: expert term→1), gamma≈2.62, beta≈0.03
+    "sl_10": [(0, 3), (0, 15), (0, 2), (0, 100), (0, 6), (0, 2)],
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 4, "sl_2": 5, "sl_3": 6, "sl_4": 6, "sl_5": 6,
+    "sl_6": 6, "sl_7": 6, "sl_8": 4, "sl_9": 4, "sl_10": 6,
+}

moe_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bee730d20bf12888a1ecb2c72977a1049728b98668cad45b4f63e4098c5f1c0
+size 2375

moe_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fad8831bc25efb889e0581d5746697b979712ca86f3b4e8002760bde554ec7b6
+size 4088

parallel_scaling_law/laws.py

@@ -0,0 +1,393 @@
+"""Scaling laws for parallel (tensor/pipeline) scaling.
+
+X columns: [num_params (N), parallel_size (S)]
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+
+
+# sl_1 (6p): c0 + cN * N^(-α) + cS * S^(-β) + cNS * N^(-α) * S^(-β)
+# theta: [c0, cN, alpha, cS, beta, cNS]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    c0, cN, alpha, cS, beta, cNS = [theta[:, i] for i in range(6)]
+    Na = N[None, :] ** (-alpha[:, None])   # (B, M)
+    Sb = S[None, :] ** (-beta[:, None])    # (B, M)
+    NaSb = Na * Sb
+    pred = c0[:, None] + cN[:, None] * Na + cS[:, None] * Sb + cNS[:, None] * NaSb
+
+    # Jacobian: d/d[c0, cN, alpha, cS, beta, cNS]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))  # (1, M) or (B, M) after broadcast
+    logS = xp.log(ops.clamp_min(S[None, :], _EPS))
+
+    d_c0 = ones
+    d_cN = Na
+    # d(Na)/d(alpha) = d(N^(-alpha))/d(alpha) = -N^(-alpha)*log(N) = -Na*logN
+    d_alpha = (cN[:, None] * Na + cNS[:, None] * NaSb) * (-logN)
+    d_cS = Sb
+    # d(Sb)/d(beta) = -Sb*logS
+    d_beta = (cS[:, None] * Sb + cNS[:, None] * NaSb) * (-logS)
+    d_cNS = NaSb
+    jac = ops.stack([d_c0, d_cN, d_alpha, d_cS, d_beta, d_cNS], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_2 (5p): c0 + cN * N^(-α) + cS * S^(-β)
+# theta: [c0, cN, alpha, cS, beta]
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    c0, cN, alpha, cS, beta = [theta[:, i] for i in range(5)]
+    Na = N[None, :] ** (-alpha[:, None])
+    Sb = S[None, :] ** (-beta[:, None])
+    pred = c0[:, None] + cN[:, None] * Na + cS[:, None] * Sb
+
+    # Jacobian: d/d[c0, cN, alpha, cS, beta]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+    logS = xp.log(ops.clamp_min(S[None, :], _EPS))
+
+    d_c0 = ones
+    d_cN = Na
+    d_alpha = cN[:, None] * Na * (-logN)
+    d_cS = Sb
+    d_beta = cS[:, None] * Sb * (-logS)
+    jac = ops.stack([d_c0, d_cN, d_alpha, d_cS, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_3 (4p): a * N^b + c / (1 + S) + d
+# theta: [a, b, c, d]
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    a, b, c, d = [theta[:, i] for i in range(4)]
+    Nb = N[None, :] ** b[:, None]
+    inv_1pS = 1.0 / (1.0 + S[None, :])
+    pred = a[:, None] * Nb + c[:, None] * inv_1pS + d[:, None]
+
+    # Jacobian: d/d[a, b, c, d]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+
+    d_a = Nb
+    d_b = a[:, None] * Nb * logN
+    d_c = inv_1pS + ones * 0.0  # broadcast
+    d_d = ones
+    jac = ops.stack([d_a, d_b, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_4 (4p): a * N^b + c * S^(-0.5) + d  (fixed beta=0.5)
+# theta: [a, b, c, d]
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    a, b, c, d = [theta[:, i] for i in range(4)]
+    Nb = N[None, :] ** b[:, None]
+    S_inv_half = S[None, :] ** (-0.5)
+    pred = a[:, None] * Nb + c[:, None] * S_inv_half + d[:, None]
+
+    # Jacobian: d/d[a, b, c, d]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+
+    d_a = Nb
+    d_b = a[:, None] * Nb * logN
+    d_c = S_inv_half + ones * 0.0  # broadcast
+    d_d = ones
+    jac = ops.stack([d_a, d_b, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_5 (4p): (A / (N * (k * log(S) + 1)))^α + E
+# theta: [A, k, alpha, E]
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], 1.0)
+    A, k, alpha, E = [theta[:, i] for i in range(4)]
+    logS = xp.log(S[None, :])
+    denom = N[None, :] * (k[:, None] * logS + 1.0)
+    denom = ops.clamp_min(denom, _EPS)
+    base = A[:, None] / denom
+    base = ops.clamp_min(base, _EPS)
+    power = base ** alpha[:, None]  # base^alpha
+    pred = power + E[:, None]
+
+    # Jacobian: d/d[A, k, alpha, E]
+    # Let f = base^alpha, pred = f + E
+    # base = A / denom, denom = N*(k*logS + 1)
+    ones = pred * 0.0 + 1.0
+    log_base = xp.log(ops.clamp_min(base, _EPS))
+
+    # d(pred)/dA: d(base^alpha)/dA = alpha * base^(alpha-1) * (1/denom)
+    #           = alpha * base^alpha * (1/base) * (1/denom) = alpha * power / A[:, None]
+    # But safer: alpha * power * (1/base) * d(base)/dA = alpha * power / base * (1/denom)
+    #          = alpha * power / (A/denom) * (1/denom) = alpha * power / A
+    d_A = alpha[:, None] * power / ops.clamp_min(A[:, None], _EPS)
+
+    # d(pred)/dk: d(base^alpha)/dk = alpha * base^(alpha-1) * d(base)/dk
+    # d(base)/dk = A * d(1/denom)/dk = -A * logS * N / denom^2 = -base * logS * N / denom
+    # Actually: d(base)/dk = -A * N * logS / denom^2 = -(A/denom) * (N*logS)/denom = -base * logS / (k*logS+1)
+    # Simpler: d(base)/dk = -A * N * logS / denom^2
+    # So d(f)/dk = alpha * power / base * (-A * N * logS / denom^2)
+    #            = alpha * power * (-N * logS / denom) / base ... hmm
+    # Let's use: d(log(base))/dk = d(log(A) - log(denom))/dk = -d(log(denom))/dk
+    # d(log(denom))/dk = N*logS / denom ... but denom = N*(k*logS+1)
+    # d(denom)/dk = N*logS, so d(log(denom))/dk = N*logS/denom = logS/(k*logS+1)
+    # d(f)/dk = f * alpha * d(log(base))/dk = -power * alpha * logS / (k[:, None] * logS + 1.0)
+    k_logS_1 = ops.clamp_min(k[:, None] * logS + 1.0, _EPS)
+    d_k = -power * alpha[:, None] * logS / k_logS_1
+
+    # d(pred)/dalpha: d(base^alpha)/dalpha = base^alpha * log(base) = power * log(base)
+    d_alpha = power * log_base
+
+    d_E = ones
+    jac = ops.stack([d_A, d_k, d_alpha, d_E], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_6 (4p): c0 + c1 * (N^(-α) + S^(-β))
+# theta: [c0, c1, alpha, beta]
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    c0, c1, alpha, beta = [theta[:, i] for i in range(4)]
+    Na = N[None, :] ** (-alpha[:, None])
+    Sb = S[None, :] ** (-beta[:, None])
+    sumNS = Na + Sb
+    pred = c0[:, None] + c1[:, None] * sumNS
+
+    # Jacobian: d/d[c0, c1, alpha, beta]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+    logS = xp.log(ops.clamp_min(S[None, :], _EPS))
+
+    d_c0 = ones
+    d_c1 = sumNS
+    d_alpha = c1[:, None] * Na * (-logN)
+    d_beta = c1[:, None] * Sb * (-logS)
+    jac = ops.stack([d_c0, d_c1, d_alpha, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_7 (4p): L0 + A * N^(-α) / (1 + k * ln(S))
+# theta: [L0, A, alpha, k]
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], 1.0)
+    L0, A, alpha, k = [theta[:, i] for i in range(4)]
+    Na = N[None, :] ** (-alpha[:, None])
+    logS = xp.log(S[None, :])
+    denom = 1.0 + k[:, None] * logS
+    denom = ops.clamp_min(denom, _EPS)
+    numer = A[:, None] * Na
+    frac = numer / denom
+    pred = L0[:, None] + frac
+
+    # Jacobian: d/d[L0, A, alpha, k]
+    ones = pred * 0.0 + 1.0
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+
+    d_L0 = ones
+    d_A = Na / denom
+    # d(frac)/d(alpha) = A * d(Na)/d(alpha) / denom = A * (-Na*logN) / denom = -frac * logN
+    d_alpha = -frac * logN
+    # d(frac)/dk = -numer * logS / denom^2 = -frac * logS / denom
+    d_k = -frac * logS / denom
+    jac = ops.stack([d_L0, d_A, d_alpha, d_k], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_8 (4p): (a * N^b + c) / (1 + d * log(S))
+# theta: [a, b, c, d]
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], 1.0)
+    a, b, c, d = [theta[:, i] for i in range(4)]
+    Nb = N[None, :] ** b[:, None]
+    logS = xp.log(S[None, :])
+    numer = a[:, None] * Nb + c[:, None]
+    denom = 1.0 + d[:, None] * logS
+    denom = ops.clamp_min(denom, _EPS)
+    pred = numer / denom
+
+    # Jacobian: d/d[a, b, c, d]
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+    inv_denom = 1.0 / denom
+
+    d_a = Nb * inv_denom                               # d(numer)/da = N^b
+    d_b = a[:, None] * Nb * logN * inv_denom            # d(numer)/db = a * N^b * logN
+    d_c = inv_denom                                     # d(numer)/dc = 1
+    d_d = -numer * logS * inv_denom ** 2                # d(denom)/dd = logS → quotient rule
+    jac = ops.stack([d_a, d_b, d_c, d_d], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_9 (3p): A * N^(-α) * S^(-β)
+# theta: [A, alpha, beta]
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    A, alpha, beta = [theta[:, i] for i in range(3)]
+    Na = N[None, :] ** (-alpha[:, None])
+    Sb = S[None, :] ** (-beta[:, None])
+    pred = A[:, None] * Na * Sb
+
+    # Jacobian: d/d[A, alpha, beta]
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+    logS = xp.log(ops.clamp_min(S[None, :], _EPS))
+
+    d_A = Na * Sb                   # pred / A
+    d_alpha = pred * (-logN)        # d(N^(-alpha))/dalpha = -N^(-alpha)*logN
+    d_beta = pred * (-logS)
+    jac = ops.stack([d_A, d_alpha, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_10 (4p): (A * N^(-α) + E) * S^(-β)
+# theta: [A, alpha, E, beta]
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    N = ops.clamp_min(X[:, 0], _EPS)
+    S = ops.clamp_min(X[:, 1], _EPS)
+    A, alpha, E, beta = [theta[:, i] for i in range(4)]
+    Na = N[None, :] ** (-alpha[:, None])
+    Sb = S[None, :] ** (-beta[:, None])
+    bracket = A[:, None] * Na + E[:, None]  # (A*N^(-alpha) + E)
+    pred = bracket * Sb
+
+    # Jacobian: d/d[A, alpha, E, beta]
+    logN = xp.log(ops.clamp_min(N[None, :], _EPS))
+    logS = xp.log(ops.clamp_min(S[None, :], _EPS))
+
+    d_A = Na * Sb
+    # d(bracket)/dalpha = A * (-Na * logN), then * Sb
+    d_alpha = A[:, None] * Na * (-logN) * Sb
+    d_E = Sb
+    # d(pred)/dbeta = bracket * d(Sb)/dbeta = bracket * (-Sb * logS) = -pred * logS
+    d_beta = -pred * logS
+    jac = ops.stack([d_A, d_alpha, d_E, d_beta], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+PARAM_BOUNDS = {
+    # Dataset: N ∈ [5.4e8, 4.4e9], log(N) ∈ [20.1, 22.2]; S ∈ {1,2,4,8}; loss ∈ [0.98, 2.11]
+    # Groups (pile/stack) have different loss floors; fit per group.
+    # sl_1: [c0, cN, alpha, cS, beta, cNS] — c0+cN*N^(-alpha)+cS*S^(-beta)+cNS*N^(-alpha)*S^(-beta)
+    # Fit pile: [1.38, 112.7, 0.260, 0.097, 0.399, 5.69]; stack: [0.763, 66.0, 0.263, 0.049, 0.470, 5.39]
+    "sl_1": [(-5, 5), (0, 500), (0, 2), (-50, 50), (0, 2), (-100, 100)],
+    # sl_2: [c0, cN, alpha, cS, beta] — c0 + cN*N^(-alpha) + cS*S^(-beta)
+    # Fit pile: [1.364, 117.8, 0.261, 0.121, 0.399]; stack: [0.750, 70.7, 0.264, 0.070, 0.472]
+    "sl_2": [(-5, 5), (0, 500), (0, 2), (-50, 50), (0, 2)],
+    # sl_3: [a, b, c, d] — a*N^b + c/(1+S) + d; b<0 required (more params → lower loss)
+    # Fit pile: [117.9, -0.261, 0.174, 1.398]; stack: [70.7, -0.264, 0.112, 0.764]
+    "sl_3": [(0, 500), (-2, 0), (-5, 5), (-5, 5)],
+    # sl_4: [a, b, c, d] — a*N^b + c*S^(-0.5) + d; b<0 required
+    # Fit pile: [117.9, -0.261, 0.105, 1.381]; stack: [70.7, -0.264, 0.068, 0.753]
+    "sl_4": [(0, 500), (-2, 0), (-5, 5), (-5, 5)],
+    # sl_5: [A, k, alpha, E] — (A/(N*(k*log(S)+1)))^alpha + E
+    # A must be ~N*constant: A/N_min ∈ [0.02, 1.85] for physical predictions
+    # Fit pile: [1.95e8, 0.334, 0.196, 1.291]; stack: [1.14e7, 0.396, 0.199, 0.709]
+    "sl_5": [(0, 1e9), (-100, 100), (0, 3), (-5, 5)],
+    # sl_6: [c0, c1, alpha, beta] — c0 + c1*(N^(-alpha) + S^(-beta))
+    # Fit pile: [-115.8, 117.3, 0.261, ~0]; stack: [-69.4, 70.2, 0.264, ~0]
+    # c0 hits -115 for pile (old -100 bound was too tight); beta≈0 (structural degeneracy)
+    "sl_6": [(-200, 200), (-200, 200), (0, 2), (0, 2)],
+    # sl_7: [L0, A, alpha, k] — L0 + A*N^(-alpha)/(1+k*ln(S))
+    # Fit pile: [1.315, 48.1, 0.204, 0.055]; stack: [0.728, 30.6, 0.211, 0.065]
+    "sl_7": [(-5, 5), (0, 500), (0, 2), (-50, 50)],
+    # sl_8: [a, b, c, d] — (a*N^b + c)/(1+d*log(S)); b<0 required
+    # Fit pile: [118.1, -0.260, 1.472, 0.017]; stack: [71.0, -0.263, 0.812, 0.020]
+    "sl_8": [(0, 500), (-2, 0), (-5, 5), (-10, 10)],
+    # sl_9: [A, alpha, beta] — A*N^(-alpha)*S^(-beta)
+    # Fit pile: [7.73, 0.065, 0.017]; stack: [4.45, 0.067, 0.020] (small exponents)
+    "sl_9": [(0, 5000), (0, 2), (0, 2)],
+    # sl_10: [A, alpha, E, beta] — (A*N^(-alpha) + E)*S^(-beta)
+    # Fit pile: [118.1, 0.260, 1.471, 0.017]; stack: [71.0, 0.263, 0.812, 0.020]
+    "sl_10": [(0, 500), (0, 2), (-5, 5), (0, 2)],
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 6, "sl_2": 5, "sl_3": 4, "sl_4": 4, "sl_5": 4,
+    "sl_6": 4, "sl_7": 4, "sl_8": 4, "sl_9": 3, "sl_10": 4,
+}

parallel_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16f73df39117534390df840862fba13e4ce032b08c24b31b0406258987d6613c
+size 2117

parallel_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bf76fabd8f7f5f1b90543b9cb9ef83db888c5674bdc9c4dc23277bd8a92f7b7
+size 2434

registry.py

@@ -0,0 +1,176 @@
+"""Dataset registry: metadata, feature/target columns, and cost functions."""
+
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional
+
+import numpy as np
+
+
+@dataclass
+class DatasetInfo:
+    name: str
+    feature_cols: List[str]
+    target_cols: List[str]
+    group_col: str = "group"
+    cost_fn: Optional[Callable[[dict], float]] = None
+    # Extra columns needed for cost but not used as features
+    cost_extra_cols: List[str] = field(default_factory=list)
+    # Per-dataset budget checkpoints (overrides runner default if set)
+    budget_checkpoints: Optional[List[float]] = None
+
+
+def _cost_data_constrained(row: dict) -> float:
+    return 6.0 * row["params"] * row["tokens"]
+
+
+def _cost_parallel(row: dict) -> float:
+    return float(row["num_params"])
+
+
+def _cost_moe(row: dict) -> float:
+    return float(row["dense_parameter_count"]) * float(row["num_experts"])
+
+
+def _cost_easy_question(row: dict) -> float:
+    return float(row["flops"])
+
+
+def _cost_vocab(row: dict) -> float:
+    return float(row["non_vocab_parameters"]) * float(row["num_characters"])
+
+
+def _cost_lr_bsz(row: dict) -> float:
+    return 6.0 * float(row["non_embedding_param_size"]) * float(row["data_size"])
+
+
+def _cost_domain_mixture(row: dict) -> float:
+    return 1.0
+
+
+def _cost_chinchilla(row: dict) -> float:
+    return 6.0 * float(row["N"]) * float(row["D"])
+
+
+def _cost_farseer(row: dict) -> float:
+    return 6.0 * float(row["N"]) * float(row["D"])
+
+
+def _cost_sft(row: dict) -> float:
+    return float(row["sft_data_size"])
+
+
+def _cost_sae(row: dict) -> float:
+    return float(row["n"]) ** 1.6
+
+
+def _cost_distillation(row: dict) -> float:
+    return 6.0 * float(row["NS"]) * float(row["DS"])
+
+
+def _cost_sparsity(row: dict) -> float:
+    return 6.0 * row["N_dense"] * row["D1"] + 6.0 * row["N_active"] * row["D2"]
+
+
+DATASET_REGISTRY: Dict[str, DatasetInfo] = {
+    "data_constrained_scaling_law": DatasetInfo(
+        name="data_constrained_scaling_law",
+        feature_cols=["unique_tokens", "params", "tokens"],
+        target_cols=["loss"],
+        cost_fn=_cost_data_constrained,
+    ),
+    "parallel_scaling_law": DatasetInfo(
+        name="parallel_scaling_law",
+        feature_cols=["num_params", "parallel_size"],
+        target_cols=["loss"],
+        cost_fn=_cost_parallel,
+    ),
+    "moe_scaling_law": DatasetInfo(
+        name="moe_scaling_law",
+        feature_cols=["num_experts", "dense_parameter_count"],
+        target_cols=["loss_validation"],
+        cost_fn=_cost_moe,
+    ),
+    "easy_question_scaling_law": DatasetInfo(
+        name="easy_question_scaling_law",
+        feature_cols=["log_flops"],
+        target_cols=["brier_score"],
+        cost_fn=_cost_easy_question,
+        cost_extra_cols=["flops"],
+        budget_checkpoints=[0.01, 0.05, 0.1]
+    ),
+    "vocab_scaling_law": DatasetInfo(
+        name="vocab_scaling_law",
+        feature_cols=["non_vocab_parameters", "vocab_size", "num_characters"],
+        target_cols=["unigram_normalized_loss"],
+        cost_fn=_cost_vocab,
+    ),
+    "lr_bsz_scaling_law": DatasetInfo(
+        name="lr_bsz_scaling_law",
+        feature_cols=["lr", "bsz", "data_size", "non_embedding_param_size"],
+        target_cols=["lm_loss"],
+        cost_fn=_cost_lr_bsz,
+    ),
+    "domain_mixture_scaling_law": DatasetInfo(
+        name="domain_mixture_scaling_law",
+        feature_cols=[
+            "proportion_domain_1",
+            "proportion_domain_2",
+            "proportion_domain_3",
+            "proportion_domain_4",
+            "proportion_domain_5",
+        ],
+        target_cols=[
+            "loss_domain_1",
+            "loss_domain_2",
+            "loss_domain_3",
+            "loss_domain_4",
+            "loss_domain_5",
+        ],
+        cost_fn=_cost_domain_mixture,
+        budget_checkpoints=[0.2, 0.35, 0.5],
+    ),
+    "chinchilla_scaling_law": DatasetInfo(
+        name="chinchilla_scaling_law",
+        feature_cols=["N", "D"],
+        target_cols=["loss"],
+        cost_fn=_cost_chinchilla,
+    ),
+    "farseer_scaling_law": DatasetInfo(
+        name="farseer_scaling_law",
+        feature_cols=["N", "D"],
+        target_cols=["loss"],
+        cost_fn=_cost_farseer,
+    ),
+    "sft_scaling_law": DatasetInfo(
+        name="sft_scaling_law",
+        feature_cols=["sft_data_size"],
+        target_cols=["sft_loss"],
+        cost_fn=_cost_sft,
+    ),
+    "sae_scaling_law": DatasetInfo(
+        name="sae_scaling_law",
+        feature_cols=["n", "k"],
+        target_cols=["loss"],
+        cost_fn=_cost_sae,
+    ),
+    "distillation_scaling_law": DatasetInfo(
+        name="distillation_scaling_law",
+        feature_cols=["NS", "DS", "LT"],
+        target_cols=["LS"],
+        cost_fn=_cost_distillation,
+    ),
+    "sparsity_scaling_law": DatasetInfo(
+        name="sparsity_scaling_law",
+        feature_cols=["P", "N_active"],
+        target_cols=["loss"],
+        cost_fn=_cost_sparsity,
+        cost_extra_cols=["N_dense", "D1", "D2"],
+        budget_checkpoints=[0.2, 0.35, 0.5]
+    ),
+}
+
+
+def get_dataset_info(name: str) -> DatasetInfo:
+    if name not in DATASET_REGISTRY:
+        raise KeyError(f"Unknown dataset: {name}. Available: {list(DATASET_REGISTRY)}")
+    return DATASET_REGISTRY[name]

sparsity_scaling_law/laws.py

@@ -0,0 +1,220 @@
+"""Scaling laws for MoE sparsity models.
+
+X columns: [P (= N_total / N_active), N_active]
+
+sl_1 (5 params): L = exp(d1) * P^(-a) * N_active^(-b) * exp(c * log(P) * log(N_active)) + exp(d3)
+sl_2 (4 params): L = exp(d1) * P^(-a) * N_active^(-b) + exp(d3)
+sl_3 (6 params): L = exp(d1) * P^(-a) + exp(d2) * N_active^(-b) * exp(c * log(P) * log(N_active)) + exp(d3)
+sl_4 (5 params): L = exp(d1) * P^(-a) + exp(d2) * N_active^(-b) + exp(d3)
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-12
+
+
+# sl_1 (5 params): [d1, a, b, c, d3]
+# L = exp(d1) * P^(-a) * N_active^(-b) * exp(c * log(P) * log(N_active)) + exp(d3)
+#   = exp(d1 - a*log(P) - b*log(N) + c*log(P)*log(N)) + exp(d3)
+# Let term = exp(d1 - a*log_P - b*log_N + c*log_P*log_N)
+# Let base = exp(d3)
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    N_act = ops.clamp_min(X[:, 1], _EPS)
+
+    d1 = theta[:, 0]
+    a = theta[:, 1]
+    b = theta[:, 2]
+    c = theta[:, 3]
+    d3 = theta[:, 4]
+
+    log_P = xp.log(P)[None, :]   # (1, M)
+    log_N = xp.log(N_act)[None, :]  # (1, M)
+
+    term = (
+        ops.exp(d1[:, None])
+        * (P[None, :] ** (-a[:, None]))
+        * (N_act[None, :] ** (-b[:, None]))
+        * ops.exp(c[:, None] * log_P * log_N)
+    )  # (B, M)
+    base = ops.exp(d3[:, None])  # (B, M)
+    pred = term + base  # (B, M)
+
+    # Jacobian: (B, M, 5)
+    # term = exp(d1 - a*log_P - b*log_N + c*log_P*log_N)
+    # d(term)/d(d1) = term
+    # d(term)/d(a)  = -term * log_P
+    # d(term)/d(b)  = -term * log_N
+    # d(term)/d(c)  = term * log_P * log_N
+    # d(base)/d(d3) = base
+    zeros = pred * 0.0
+
+    d_d1 = term
+    d_a = -term * log_P
+    d_b = -term * log_N
+    d_c = term * log_P * log_N
+    d_d3 = zeros + base
+
+    jac = ops.stack([d_d1, d_a, d_b, d_c, d_d3], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_2 (4 params): [d1, a, b, d3]
+# L = exp(d1) * P^(-a) * N_active^(-b) + exp(d3)
+#   = exp(d1 - a*log_P - b*log_N) + exp(d3)
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    N_act = ops.clamp_min(X[:, 1], _EPS)
+
+    d1 = theta[:, 0]
+    a = theta[:, 1]
+    b = theta[:, 2]
+    d3 = theta[:, 3]
+
+    log_P = xp.log(P)[None, :]   # (1, M)
+    log_N = xp.log(N_act)[None, :]  # (1, M)
+
+    term = (
+        ops.exp(d1[:, None])
+        * (P[None, :] ** (-a[:, None]))
+        * (N_act[None, :] ** (-b[:, None]))
+    )  # (B, M)
+    base = ops.exp(d3[:, None])  # (B, M)
+    pred = term + base  # (B, M)
+
+    # Jacobian: (B, M, 4)
+    # term = exp(d1 - a*log_P - b*log_N)
+    zeros = pred * 0.0
+
+    d_d1 = term
+    d_a = -term * log_P
+    d_b = -term * log_N
+    d_d3 = zeros + base
+
+    jac = ops.stack([d_d1, d_a, d_b, d_d3], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_3 (6 params): [d1, a, d2, b, c, d3]
+# L = exp(d1) * P^(-a) + exp(d2) * N_active^(-b) * exp(c * log(P) * log(N_active)) + exp(d3)
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    N_act = ops.clamp_min(X[:, 1], _EPS)
+
+    d1 = theta[:, 0]
+    a = theta[:, 1]
+    d2 = theta[:, 2]
+    b = theta[:, 3]
+    c = theta[:, 4]
+    d3 = theta[:, 5]
+
+    log_P = xp.log(P)[None, :]   # (1, M)
+    log_N = xp.log(N_act)[None, :]  # (1, M)
+
+    term_P = ops.exp(d1[:, None]) * (P[None, :] ** (-a[:, None]))  # (B, M)
+    term_N = (
+        ops.exp(d2[:, None])
+        * (N_act[None, :] ** (-b[:, None]))
+        * ops.exp(c[:, None] * log_P * log_N)
+    )  # (B, M)
+    base = ops.exp(d3[:, None])  # (B, M)
+    pred = term_P + term_N + base  # (B, M)
+
+    # Jacobian: (B, M, 6)
+    # term_P = exp(d1 - a*log_P) => d/d(d1) = term_P, d/d(a) = -term_P*log_P
+    # term_N = exp(d2 - b*log_N + c*log_P*log_N) => d/d(d2)=term_N, d/d(b)=-term_N*log_N, d/d(c)=term_N*log_P*log_N
+    # base = exp(d3) => d/d(d3) = base
+    zeros = pred * 0.0
+
+    d_d1 = zeros + term_P
+    d_a = -term_P * log_P
+    d_d2 = zeros + term_N
+    d_b = -term_N * log_N
+    d_c = term_N * log_P * log_N
+    d_d3 = zeros + base
+
+    jac = ops.stack([d_d1, d_a, d_d2, d_b, d_c, d_d3], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_4 (5 params): [d1, a, d2, b, d3]
+# L = exp(d1) * P^(-a) + exp(d2) * N_active^(-b) + exp(d3)
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    N_act = ops.clamp_min(X[:, 1], _EPS)
+
+    d1 = theta[:, 0]
+    a = theta[:, 1]
+    d2 = theta[:, 2]
+    b = theta[:, 3]
+    d3 = theta[:, 4]
+
+    log_P = xp.log(P)[None, :]   # (1, M)
+    log_N = xp.log(N_act)[None, :]  # (1, M)
+
+    term_P = ops.exp(d1[:, None]) * (P[None, :] ** (-a[:, None]))  # (B, M)
+    term_N = ops.exp(d2[:, None]) * (N_act[None, :] ** (-b[:, None]))  # (B, M)
+    base = ops.exp(d3[:, None])  # (B, M)
+    pred = term_P + term_N + base  # (B, M)
+
+    # Jacobian: (B, M, 5)
+    zeros = pred * 0.0
+
+    d_d1 = zeros + term_P
+    d_a = -term_P * log_P
+    d_d2 = zeros + term_N
+    d_b = -term_N * log_N
+    d_d3 = zeros + base
+
+    jac = ops.stack([d_d1, d_a, d_d2, d_b, d_d3], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+LAW_REGISTRY = {"sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4}
+PARAM_COUNTS = {"sl_1": 5, "sl_2": 4, "sl_3": 6, "sl_4": 5}
+
+# Data ranges:
+#   P in [1.86, 12.25], N_active in [0.015, 1.90], loss in [2.07, 3.40]
+# d1, d2, d3: inside exp(), so reasonable range is (-5, 5)
+# a, b: positive exponents, (0.01, 3.0)
+# c: cross-term coefficient, (-1, 1)
+PARAM_BOUNDS = {
+    "sl_1": [(-5.0, 5.0), (0.01, 3.0), (0.01, 3.0), (-1.0, 1.0), (-5.0, 5.0)],
+    "sl_2": [(-5.0, 5.0), (0.01, 3.0), (0.01, 3.0), (-5.0, 5.0)],
+    "sl_3": [(-5.0, 5.0), (0.01, 3.0), (-5.0, 5.0), (0.01, 3.0), (-1.0, 1.0), (-5.0, 5.0)],
+    "sl_4": [(-5.0, 5.0), (0.01, 3.0), (-5.0, 5.0), (0.01, 3.0), (-5.0, 5.0)],
+}

sparsity_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:240f1b6315deee2167a84d1a29ebac1b349e0e0c40f41511e36ec6a42bb387c6
+size 2441

sparsity_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a91b91ba7826bf262770ed6e7ab363274810819856e99981b5ad579576796127
+size 3279

utils.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Literal
+import numpy as np
+
+Backend = Literal["numpy", "jax", "torch"]
+
+@dataclass
+class BackendOps:
+    backend: Backend
+    xp: object
+
+    def asarray(self, x, atleast_2d: bool = False):
+        if self.backend == "torch":
+            if isinstance(x, self.xp.Tensor):
+                arr = x.to(dtype=self.xp.float64)
+            else:
+                arr = self.xp.as_tensor(x, dtype=self.xp.float64)
+            if atleast_2d and arr.ndim < 2:
+                if arr.ndim == 1:
+                    arr = arr.unsqueeze(0)
+                else:
+                    arr = arr.reshape(1, 1)
+            return arr
+
+        arr = self.xp.asarray(x, dtype=self.xp.float64)
+        if atleast_2d:
+            arr = self.xp.atleast_2d(arr)
+        return arr
+
+    def maximum(self, x, y):
+        return self.xp.maximum(x, y)
+
+    def minimum(self, x, y):
+        return self.xp.minimum(x, y)
+
+    def clamp(self, x, min=None, max=None):
+        if self.backend == "torch":
+            return self.xp.clamp(x, min=min, max=max)
+        if min is not None:
+            x = self.xp.maximum(x, min)
+        if max is not None:
+            x = self.xp.minimum(x, max)
+        return x
+
+    def clamp_min(self, x, min_value):
+        return self.maximum(x, min_value)
+
+    def clamp_max(self, x, max_value):
+        return self.minimum(x, max_value)
+
+    def exp(self, x):
+        return self.xp.exp(x)
+
+    def stack(self, arrays, axis=-1):
+        if self.backend == "torch":
+            return self.xp.stack(arrays, dim=axis)
+        return self.xp.stack(arrays, axis=axis)
+
+def get_ops(backend: Backend) -> BackendOps:
+    if backend == "numpy":
+        xp = np
+    elif backend == "jax":
+        import jax.numpy as jnp
+        xp = jnp
+    elif backend == "torch":
+        import torch
+        xp = torch
+    else:
+        raise ValueError(f"Unsupported backend: {backend}")
+
+    return BackendOps(backend=backend, xp=xp)

vocab_scaling_law/laws.py

@@ -0,0 +1,630 @@
+"""Scaling laws for vocabulary size scaling.
+
+X columns: [non_vocab_parameters (P), vocab_size (V), num_characters (D)]
+"""
+
+from typing import Literal
+
+import benchmark.dataset.utils as utils
+
+_EPS = 1e-6
+
+
+# sl_1 (5p): c0 + A * V^b * P^e * D^g
+# theta: [c0, A, b, e, g]
+def sl_1(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    c0, A, b, e, g = [theta[:, i] for i in range(5)]
+
+    logP = xp.log(ops.clamp_min(P, _EPS))
+    logV = xp.log(ops.clamp_min(V, _EPS))
+    logD = xp.log(ops.clamp_min(D, _EPS))
+
+    V_b = V[None, :] ** b[:, None]
+    P_e = P[None, :] ** e[:, None]
+    D_g = D[None, :] ** g[:, None]
+    term = A[:, None] * V_b * P_e * D_g  # A * V^b * P^e * D^g
+
+    pred = c0[:, None] + term
+
+    ones = pred * 0.0 + 1.0
+
+    # d/d(c0) = 1
+    d_c0 = ones
+    # d/d(A) = V^b * P^e * D^g
+    d_A = V_b * P_e * D_g
+    # d/d(b) = term * log(V)
+    d_b = term * logV[None, :]
+    # d/d(e) = term * log(P)
+    d_e = term * logP[None, :]
+    # d/d(g) = term * log(D)
+    d_g = term * logD[None, :]
+
+    jac = ops.stack([d_c0, d_A, d_b, d_e, d_g], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_2 (7p): L + A * M_r(P^-alpha, D^-beta) * (1 + C * (log(V) - v0)^2)
+# Generalized power mean with quadratic vocab gate
+# M_r(x,y) = ((x^r + y^r)/2)^(1/r)
+# theta: [L, A, alpha, beta, C, v0, r]
+def sl_2(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    L, A, alpha, beta, C, v0, r = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logD = xp.log(D)
+    logV = xp.log(V)
+
+    r_safe = ops.clamp_min(r, _EPS)
+    inv_r = 1.0 / r_safe
+
+    # ── All heavy lifting in log-space ──────────────────────────
+    # log(tp_r) = -alpha * r * log(P),  log(td_r) = -beta * r * log(D)
+    log_tp_r = -alpha[:, None] * r_safe[:, None] * logP[None, :]
+    log_td_r = -beta[:, None] * r_safe[:, None] * logD[None, :]
+
+    # log(S) = log((tp_r + td_r)/2)  via logsumexp
+    log_max = xp.maximum(log_tp_r, log_td_r)
+    log_sum_raw = log_max + xp.log(
+        xp.exp(log_tp_r - log_max) + xp.exp(log_td_r - log_max)
+    )
+    log_S = log_sum_raw - xp.log(2.0)   # = log((tp_r+td_r)/2)
+
+    # mean_r = S^(1/r) = exp(log_S / r), clipped to prevent overflow
+    _LOG_CLIP = 50.0
+    log_mean_r = xp.clip(log_S * inv_r[:, None], -_LOG_CLIP, _LOG_CLIP)
+    mean_r = xp.exp(log_mean_r)
+
+    # ── Stable ratio via sigmoid ────────────────────────────────
+    # tp_r / (tp_r + td_r) = sigmoid(log_tp_r - log_td_r)
+    # td_r / (tp_r + td_r) = sigmoid(log_td_r - log_tp_r)
+    # Note: tp_r / (2*S) = tp_r / (tp_r + td_r) = sigmoid(diff)
+    diff = log_tp_r - log_td_r
+    diff_clip = xp.clip(diff, -_LOG_CLIP, _LOG_CLIP)
+    sig_p = 1.0 / (1.0 + xp.exp(-diff_clip))   # = tp_r/(tp_r+td_r)
+    sig_d = 1.0 - sig_p                          # = td_r/(tp_r+td_r)
+
+    # ── Vocab gate ──────────────────────────────────────────────
+    lV_diff = logV[None, :] - v0[:, None]
+    lV_diff2 = lV_diff ** 2
+    vocab_gate = 1.0 + C[:, None] * lV_diff2
+
+    # ── Prediction ──────────────────────────────────────────────
+    product = mean_r * vocab_gate
+    pred = L[:, None] + A[:, None] * product
+
+    # ── Jacobian ────────────────────────────────────────────────
+    d_L = xp.ones_like(pred)
+    d_A = product
+
+    # d/d(alpha): mean_r * tp_r/(2S) * logP = mean_r * sig_p * logP
+    d_alpha = A[:, None] * vocab_gate * (-mean_r * sig_p * logP[None, :])
+
+    # d/d(beta): mean_r * td_r/(2S) * logD = mean_r * sig_d * logD
+    d_beta = A[:, None] * vocab_gate * (-mean_r * sig_d * logD[None, :])
+
+    d_C = A[:, None] * mean_r * lV_diff2
+    d_v0 = A[:, None] * mean_r * (-2.0 * C[:, None] * lV_diff)
+
+    # d/d(r): dmr_dr = mean_r * [(-1/r²)*log_S + (1/r)*(sig_p*log_term_p + sig_d*log_term_d)]
+    # where log_term_p = -alpha*logP, log_term_d = -beta*logD
+    log_term_p = -alpha[:, None] * logP[None, :]
+    log_term_d = -beta[:, None] * logD[None, :]
+    dlogS_dr_over_r = sig_p * log_term_p + sig_d * log_term_d  # = (1/S)*dS/dr
+    dmr_dr = mean_r * (
+        -inv_r[:, None] ** 2 * xp.clip(log_S, -_LOG_CLIP, _LOG_CLIP)
+        + inv_r[:, None] * dlogS_dr_over_r
+    )
+    d_r = A[:, None] * vocab_gate * dmr_dr
+
+    jac = ops.stack([d_L, d_A, d_alpha, d_beta, d_C, d_v0, d_r], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+
+# sl_3 (7p): L0 + ((a * P^-alpha)^q + (b * (D * V^phi)^-beta)^q)^(1/q)
+# Generalized q-mean of two Chinchilla-style terms
+# theta: [L0, a, alpha, b, beta, phi, q]
+def sl_3(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    L0, a, alpha, b, beta, phi, q = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    q_safe = ops.clamp_min(q, _EPS)
+    inv_q = 1.0 / q_safe
+
+    _LOG_CLIP = 50.0
+
+    # ── Log-space for t1, t2 ───────────────────────────────────
+    # t1 = a * P^(-alpha)  =>  log_t1 = log(a) + (-alpha)*log(P)
+    log_a = xp.log(ops.clamp_min(a, _EPS))
+    log_b = xp.log(ops.clamp_min(b, _EPS))
+
+    log_t1 = log_a[:, None] + (-alpha[:, None]) * logP[None, :]
+
+    # t2 = b * (D * V^phi)^(-beta)
+    # log_t2 = log(b) + (-beta)*(log(D) + phi*log(V))
+    log_eff_D = logD[None, :] + phi[:, None] * logV[None, :]
+    log_t2 = log_b[:, None] + (-beta[:, None]) * log_eff_D
+
+    # ── Log-space for S = t1^q + t2^q ─────────────────────────
+    # log_t1_q = q * log_t1,  log_t2_q = q * log_t2
+    log_t1_q = q_safe[:, None] * log_t1
+    log_t2_q = q_safe[:, None] * log_t2
+
+    # log_S = logsumexp(log_t1_q, log_t2_q)
+    log_max = xp.maximum(log_t1_q, log_t2_q)
+    log_S = log_max + xp.log(
+        xp.exp(log_t1_q - log_max) + xp.exp(log_t2_q - log_max)
+    )
+
+    # combined = S^(1/q) = exp(log_S / q)
+    log_combined = xp.clip(log_S * inv_q[:, None], -_LOG_CLIP, _LOG_CLIP)
+    combined = xp.exp(log_combined)
+
+    # ── Stable ratios via sigmoid ──────────────────────────────
+    # t1_q / S = sigmoid(log_t1_q - log_t2_q)
+    # t2_q / S = sigmoid(log_t2_q - log_t1_q)
+    diff = xp.clip(log_t1_q - log_t2_q, -_LOG_CLIP, _LOG_CLIP)
+    sig_1 = 1.0 / (1.0 + xp.exp(-diff))    # = t1^q / S
+    sig_2 = 1.0 - sig_1                      # = t2^q / S
+
+    # ── Prediction ─────────────────────────────────────────────
+    pred = L0[:, None] + combined
+
+    # ── Jacobian ───────────────────────────────────────────────
+    # Shared factor: d(combined)/d(S) * d(S)/d(t_k^q) * d(t_k^q)/d(...)
+    # d(combined)/d(S) = combined / (q * S)
+    # d(S)/d(t1_q) = 1
+    # d(t1_q)/d(theta) = t1_q * q * d(log_t1)/d(theta)
+    #
+    # Chain: d(combined)/d(log_t1) = combined / (q*S) * t1_q * q
+    #                               = combined * (t1_q / S)
+    #                               = combined * sig_1
+    # Similarly for t2.
+
+    d_L0 = xp.ones_like(pred)
+
+    # d/d(a): d(log_t1)/d(a) = 1/a
+    #   => d(combined)/d(a) = combined * sig_1 * q * (1/a)
+    d_a = combined * sig_1 * q_safe[:, None] / a[:, None]
+
+    # d/d(alpha): d(log_t1)/d(alpha) = -logP
+    #   => d(t1_q)/d(alpha) = t1_q * q * (-logP)
+    #   => d(combined)/d(alpha) = combined * sig_1 * q * (-logP)
+    d_alpha = combined * sig_1 * q_safe[:, None] * (-logP[None, :])
+
+    # d/d(b): d(log_t2)/d(b) = 1/b
+    d_b = combined * sig_2 * q_safe[:, None] / b[:, None]
+
+    # d/d(beta): d(log_t2)/d(beta) = -log_eff_D
+    d_beta = combined * sig_2 * q_safe[:, None] * (-log_eff_D)
+
+    # d/d(phi): d(log_t2)/d(phi) = (-beta) * logV
+    d_phi = combined * sig_2 * q_safe[:, None] * (-beta[:, None]) * logV[None, :]
+
+    # d/d(q):
+    #   combined = S^(1/q),  log(combined) = log_S / q
+    #   d(combined)/d(q) = combined * [ -log_S/q² + (1/q)(1/S)*dS/dq ]
+    #
+    #   dS/dq = t1_q * log_t1 + t2_q * log_t2
+    #   (1/S)*dS/dq = sig_1 * log_t1 + sig_2 * log_t2
+    #
+    #   Use clipped log values throughout
+    log_t1_clip = xp.clip(log_t1, -_LOG_CLIP, _LOG_CLIP)
+    log_t2_clip = xp.clip(log_t2, -_LOG_CLIP, _LOG_CLIP)
+    log_S_clip = xp.clip(log_S, -_LOG_CLIP, _LOG_CLIP)
+
+    inv_S_dS_dq = sig_1 * log_t1_clip + sig_2 * log_t2_clip
+
+    d_q = combined * (
+        -inv_q[:, None] ** 2 * log_S_clip
+        + inv_q[:, None] * inv_S_dS_dq
+    )
+
+    jac = ops.stack([d_L0, d_a, d_alpha, d_b, d_beta, d_phi, d_q], axis=-1)
+
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+_LOG_CLIP = 50.0
+
+
+# sl_4 (7p): L_inf + A * max(P^a, lambda*D^b)^(-d) * V^(-g)
+# theta: [L_inf, A, a, b, d, lam, g]
+def sl_4(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    L_inf, A_p, a, b, d_p, lam, g = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logD = xp.log(D)
+    logV = xp.log(V)
+
+    # log(P^a) = a*logP,  log(lam*D^b) = log(lam) + b*logD
+    log_t1 = a[:, None] * logP[None, :]
+    log_lam = xp.log(ops.clamp_min(lam, _EPS))
+    log_t2 = log_lam[:, None] + b[:, None] * logD[None, :]
+    log_max = xp.maximum(log_t1, log_t2)
+
+    # term = A * max(...)^(-d) * V^(-g) = A * exp(-d*log_max - g*logV)
+    log_term = xp.log(ops.clamp_min(A_p, _EPS))[:, None] \
+               - d_p[:, None] * log_max - g[:, None] * logV[None, :]
+    log_term = xp.clip(log_term, -_LOG_CLIP, _LOG_CLIP)
+    term = xp.exp(log_term)
+
+    pred = L_inf[:, None] + term
+
+    # Indicator for which branch is active
+    ind1 = (log_t1 >= log_t2) * 1.0
+    ind2 = 1.0 - ind1
+
+    d_L_inf = xp.ones_like(pred)
+    # d/dA = term / A
+    d_A = term / ops.clamp_min(A_p, _EPS)[:, None]
+    # d/da = term * (-d) * ind1 * logP
+    d_a = term * (-d_p[:, None]) * ind1 * logP[None, :]
+    # d/db = term * (-d) * ind2 * logD
+    d_b = term * (-d_p[:, None]) * ind2 * logD[None, :]
+    # d/dd = term * (-log_max)
+    d_d = term * (-log_max)
+    # d/dlam = term * (-d) * ind2 / lam
+    d_lam = term * (-d_p[:, None]) * ind2 / ops.clamp_min(lam, _EPS)[:, None]
+    # d/dg = term * (-logV)
+    d_g = term * (-logV[None, :])
+
+    jac = ops.stack([d_L_inf, d_A, d_a, d_b, d_d, d_lam, d_g], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_5 (7p): p0 * P^p1 * V^p2 * D^p3 + p4 * P^p5 + p6
+# theta: [p0, p1, p2, p3, p4, p5, p6]
+def sl_5(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    p0, p1, p2, p3, p4, p5, p6 = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    # t1 = p0 * P^p1 * V^p2 * D^p3
+    # log|t1| = log|p0| + p1*logP + p2*logV + p3*logD
+    log_t1_abs = xp.log(ops.clamp_min(xp.abs(p0), _EPS))[:, None] \
+                 + p1[:, None] * logP[None, :] \
+                 + p2[:, None] * logV[None, :] \
+                 + p3[:, None] * logD[None, :]
+    log_t1_abs = xp.clip(log_t1_abs, -_LOG_CLIP, _LOG_CLIP)
+    sign_p0 = xp.sign(p0)
+    t1 = sign_p0[:, None] * xp.exp(log_t1_abs)
+
+    # t2 = p4 * P^p5
+    log_t2_abs = xp.log(ops.clamp_min(xp.abs(p4), _EPS))[:, None] \
+                 + p5[:, None] * logP[None, :]
+    log_t2_abs = xp.clip(log_t2_abs, -_LOG_CLIP, _LOG_CLIP)
+    sign_p4 = xp.sign(p4)
+    t2 = sign_p4[:, None] * xp.exp(log_t2_abs)
+
+    pred = t1 + t2 + p6[:, None]
+
+    # Power-law parts (unsigned, for Jacobian): P^p1*V^p2*D^p3, P^p5
+    pvd = xp.exp(xp.clip(
+        p1[:, None] * logP[None, :] + p2[:, None] * logV[None, :] + p3[:, None] * logD[None, :],
+        -_LOG_CLIP, _LOG_CLIP))
+    pp5 = xp.exp(xp.clip(p5[:, None] * logP[None, :], -_LOG_CLIP, _LOG_CLIP))
+
+    d_p0 = sign_p0[:, None] * pvd  # preserves sign correctly when p0 < 0
+    d_p1 = t1 * logP[None, :]
+    d_p2 = t1 * logV[None, :]
+    d_p3 = t1 * logD[None, :]
+    d_p4 = sign_p4[:, None] * pp5
+    d_p5 = t2 * logP[None, :]
+    d_p6 = xp.ones_like(pred)
+
+    jac = ops.stack([d_p0, d_p1, d_p2, d_p3, d_p4, d_p5, d_p6], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_6 (7p): A * (P * V^k1)^(-alpha) + B * (D * V^k2)^(-beta) + c0
+# theta: [A, alpha, k1, B, beta, k2, c0]
+def sl_6(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    A, alpha, k1, B, beta, k2, c0 = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    # log_eff_P = logP + k1*logV,  log_eff_D = logD + k2*logV
+    log_eff_P = logP[None, :] + k1[:, None] * logV[None, :]
+    log_eff_D = logD[None, :] + k2[:, None] * logV[None, :]
+
+    # term1 = A * exp(-alpha * log_eff_P)
+    log_term1 = xp.log(ops.clamp_min(A, _EPS))[:, None] \
+                - alpha[:, None] * log_eff_P
+    log_term1 = xp.clip(log_term1, -_LOG_CLIP, _LOG_CLIP)
+    term1 = xp.exp(log_term1)
+
+    # term2 = B * exp(-beta * log_eff_D)
+    log_term2 = xp.log(ops.clamp_min(B, _EPS))[:, None] \
+                - beta[:, None] * log_eff_D
+    log_term2 = xp.clip(log_term2, -_LOG_CLIP, _LOG_CLIP)
+    term2 = xp.exp(log_term2)
+
+    pred = term1 + term2 + c0[:, None]
+
+    d_A = term1 / ops.clamp_min(A, _EPS)[:, None]
+    d_alpha = -term1 * log_eff_P
+    d_k1 = -term1 * alpha[:, None] * logV[None, :]
+    d_B = term2 / ops.clamp_min(B, _EPS)[:, None]
+    d_beta = -term2 * log_eff_D
+    d_k2 = -term2 * beta[:, None] * logV[None, :]
+    d_c0 = xp.ones_like(pred)
+
+    jac = ops.stack([d_A, d_alpha, d_k1, d_B, d_beta, d_k2, d_c0], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_7 (7p): A * P^(-alpha) * D^(-beta) + B * V^gamma * D^(-delta) + c0
+# theta: [A, alpha, beta, B, gamma, delta, c0]
+def sl_7(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    A, alpha, beta, B, gamma, delta, c0 = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    # t1 = A * P^(-alpha) * D^(-beta) = A * exp(-alpha*logP - beta*logD)
+    log_t1 = xp.log(ops.clamp_min(A, _EPS))[:, None] \
+             - alpha[:, None] * logP[None, :] \
+             - beta[:, None] * logD[None, :]
+    log_t1 = xp.clip(log_t1, -_LOG_CLIP, _LOG_CLIP)
+    t1 = xp.exp(log_t1)
+
+    # t2 = B * V^gamma * D^(-delta) = B * exp(gamma*logV - delta*logD)
+    log_t2 = xp.log(ops.clamp_min(B, _EPS))[:, None] \
+             + gamma[:, None] * logV[None, :] \
+             - delta[:, None] * logD[None, :]
+    log_t2 = xp.clip(log_t2, -_LOG_CLIP, _LOG_CLIP)
+    t2 = xp.exp(log_t2)
+
+    pred = t1 + t2 + c0[:, None]
+
+    d_A = t1 / ops.clamp_min(A, _EPS)[:, None]
+    d_alpha = -t1 * logP[None, :]
+    d_beta = -t1 * logD[None, :]
+    d_B = t2 / ops.clamp_min(B, _EPS)[:, None]
+    d_gamma = t2 * logV[None, :]
+    d_delta = -t2 * logD[None, :]
+    d_c0 = xp.ones_like(pred)
+
+    jac = ops.stack([d_A, d_alpha, d_beta, d_B, d_gamma, d_delta, d_c0], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_8 (7p): c0 + c1*log(V) + V^beta * (c2 * P^(-alpha) + c3 * D^(-gamma))
+# theta: [c0, c1, c2, alpha, c3, gamma, beta]
+def sl_8(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    c0, c1, c2, alpha, c3, gamma, beta = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    # V^beta * c2 * P^(-alpha) = c2 * exp(beta*logV - alpha*logP)
+    log_vp = beta[:, None] * logV[None, :] - alpha[:, None] * logP[None, :]
+    log_vp = xp.clip(log_vp, -_LOG_CLIP, _LOG_CLIP)
+    vp = xp.exp(log_vp)   # V^beta * P^(-alpha)
+
+    # V^beta * c3 * D^(-gamma) = c3 * exp(beta*logV - gamma*logD)
+    log_vd = beta[:, None] * logV[None, :] - gamma[:, None] * logD[None, :]
+    log_vd = xp.clip(log_vd, -_LOG_CLIP, _LOG_CLIP)
+    vd = xp.exp(log_vd)   # V^beta * D^(-gamma)
+
+    scaled = c2[:, None] * vp + c3[:, None] * vd
+    pred = c0[:, None] + c1[:, None] * logV[None, :] + scaled
+
+    d_c0 = xp.ones_like(pred)
+    d_c1 = xp.broadcast_to(logV[None, :], pred.shape) + 0.0  # force copy
+    d_c2 = vp
+    d_alpha = c2[:, None] * vp * (-logP[None, :])
+    d_c3 = vd
+    d_gamma = c3[:, None] * vd * (-logD[None, :])
+    d_beta = scaled * logV[None, :]
+
+    jac = ops.stack([d_c0, d_c1, d_c2, d_alpha, d_c3, d_gamma, d_beta], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_9 (7p): A * P^(-alpha) * D^(-beta) * (1 + gamma*log(V)) + delta * V^epsilon + L_inf
+# theta: [A, alpha, beta, gamma, delta, epsilon, L_inf]
+def sl_9(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    A, alpha, beta, gamma, delta, epsilon, L_inf = [theta[:, i] for i in range(7)]
+
+    logP = xp.log(P)
+    logV = xp.log(V)
+    logD = xp.log(D)
+
+    # main = A * P^(-alpha) * D^(-beta) = A * exp(-alpha*logP - beta*logD)
+    log_main = xp.log(ops.clamp_min(A, _EPS))[:, None] \
+               - alpha[:, None] * logP[None, :] \
+               - beta[:, None] * logD[None, :]
+    log_main = xp.clip(log_main, -_LOG_CLIP, _LOG_CLIP)
+    main = xp.exp(log_main)
+
+    vocab_mod = 1.0 + gamma[:, None] * logV[None, :]
+
+    # cross = delta * V^epsilon = delta * exp(epsilon*logV)
+    log_cross = xp.log(ops.clamp_min(xp.abs(delta), _EPS))[:, None] \
+                + epsilon[:, None] * logV[None, :]
+    log_cross = xp.clip(log_cross, -_LOG_CLIP, _LOG_CLIP)
+    sign_delta = xp.sign(delta)
+    cross = sign_delta[:, None] * xp.exp(log_cross)
+
+    pred = main * vocab_mod + cross + L_inf[:, None]
+
+    d_A = main / ops.clamp_min(A, _EPS)[:, None] * vocab_mod
+    d_alpha = main * (-logP[None, :]) * vocab_mod
+    d_beta = main * (-logD[None, :]) * vocab_mod
+    d_gamma = main * logV[None, :]
+    d_delta = cross / (sign_delta[:, None] * ops.clamp_min(xp.abs(delta), _EPS)[:, None] + 1e-300) \
+              * sign_delta[:, None]  # = V^epsilon with correct sign handling
+    # Simpler: d/d(delta) = V^epsilon
+    v_eps = xp.exp(xp.clip(epsilon[:, None] * logV[None, :], -_LOG_CLIP, _LOG_CLIP))
+    d_delta = v_eps
+    d_epsilon = cross * logV[None, :]
+    d_L_inf = xp.ones_like(pred)
+
+    jac = ops.stack([d_A, d_alpha, d_beta, d_gamma, d_delta, d_epsilon, d_L_inf], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+# sl_10 (7p): L_min + exp(a + bP*log(P) + bV1*log(V) + bV2*log(V)^2 + bD*log(D) + bVD*log(V)*log(D))
+# theta: [L_min, a, bP, bV1, bV2, bD, bVD]
+def sl_10(theta, X, backend: Literal["numpy", "jax", "torch"] = "jax"):
+    ops = utils.get_ops(backend)
+    xp = ops.xp
+    X = ops.asarray(X, atleast_2d=True)
+    theta = ops.asarray(theta, atleast_2d=True)
+    P = ops.clamp_min(X[:, 0], _EPS)
+    V = ops.clamp_min(X[:, 1], _EPS)
+    D = ops.clamp_min(X[:, 2], _EPS)
+    L_min, a, bP, bV1, bV2, bD, bVD = [theta[:, i] for i in range(7)]
+
+    lP = xp.log(P[None, :])
+    lV = xp.log(V[None, :])
+    lD = xp.log(D[None, :])
+
+    exponent = (a[:, None] + bP[:, None] * lP + bV1[:, None] * lV
+                + bV2[:, None] * lV ** 2 + bD[:, None] * lD
+                + bVD[:, None] * lV * lD)
+    exponent = xp.clip(exponent, -_LOG_CLIP, _LOG_CLIP)
+    exp_val = xp.exp(exponent)
+
+    pred = L_min[:, None] + exp_val
+
+    d_L_min = xp.ones_like(pred)
+    d_a = exp_val
+    d_bP = exp_val * lP
+    d_bV1 = exp_val * lV
+    d_bV2 = exp_val * lV ** 2
+    d_bD = exp_val * lD
+    d_bVD = exp_val * lV * lD
+
+    jac = ops.stack([d_L_min, d_a, d_bP, d_bV1, d_bV2, d_bD, d_bVD], axis=-1)
+    if pred.shape[0] == 1:
+        return pred[0], jac[0]
+    return pred, jac
+
+
+PARAM_BOUNDS = {
+    # sl_1: [c0, A, b, e, g]
+    "sl_1": [(-100, 100), (-1e4, 1e4), (-5, 5), (-5, 5), (-5, 5)],
+    # sl_2: [L, A, alpha, beta, C, v0, r]
+    "sl_2": [(-100, 100), (-1e4, 1e4), (-5, 5), (-5, 5), (-100, 100), (-10, 30), (0.1, 10)],
+    # sl_3: [L0, a, alpha, b, beta, phi, q]
+    "sl_3": [(-100, 100), (-1e4, 1e4), (-5, 5), (-1e4, 1e4), (-5, 5), (-5, 5), (0.1, 10)],
+    # sl_4: [L_inf, A, a, b, d, lam, g]
+    "sl_4": [(-100, 100), (-1e4, 1e4), (-5, 5), (-5, 5), (-5, 5), (1e-6, 1e4), (-5, 5)],
+    # sl_5: [p0, p1, p2, p3, p4, p5, p6]
+    "sl_5": [(-1e4, 1e4), (-5, 5), (-5, 5), (-5, 5), (-1e4, 1e4), (-5, 5), (-100, 100)],
+    # sl_6: [A, alpha, k1, B, beta, k2, c0]
+    "sl_6": [(-1e4, 1e4), (-5, 5), (-5, 5), (-1e4, 1e4), (-5, 5), (-5, 5), (-100, 100)],
+    # sl_7: [A, alpha, beta, B, gamma, delta, c0]
+    "sl_7": [(-1e4, 1e4), (-5, 5), (-5, 5), (-1e4, 1e4), (-5, 5), (-5, 5), (-100, 100)],
+    # sl_8: [c0, c1, c2, alpha, c3, gamma, beta]
+    "sl_8": [(-100, 100), (-100, 100), (-1e4, 1e4), (-5, 5), (-1e4, 1e4), (-5, 5), (-5, 5)],
+    # sl_9: [A, alpha, beta, gamma, delta, epsilon, L_inf]
+    "sl_9": [(-1e4, 1e4), (-5, 5), (-5, 5), (-100, 100), (-1e4, 1e4), (-5, 5), (-100, 100)],
+    # sl_10: [L_min, a, bP, bV1, bV2, bD, bVD] — exp(poly) with clamp [-50,50]
+    "sl_10": [(-100, 100), (-20, 20), (-2, 2), (-2, 2), (-0.1, 0.1), (-2, 2), (-0.1, 0.1)],
+}
+
+LAW_REGISTRY = {
+    "sl_1": sl_1, "sl_2": sl_2, "sl_3": sl_3, "sl_4": sl_4, "sl_5": sl_5,
+    "sl_6": sl_6, "sl_7": sl_7, "sl_8": sl_8, "sl_9": sl_9, "sl_10": sl_10,
+}
+PARAM_COUNTS = {
+    "sl_1": 5, "sl_2": 7, "sl_3": 7, "sl_4": 7, "sl_5": 7,
+    "sl_6": 7, "sl_7": 7, "sl_8": 7, "sl_9": 7, "sl_10": 7,
+}

vocab_scaling_law/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e94a7f367168596511ee0024fe52acca6ef1a2fceef9c605b6b5b62e748396cb
+size 4341

vocab_scaling_law/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:959415949e790c46d30b445536d2a364d804c7c942398320dd0677ed3ecdf633
+size 19500