acceptodds
Under review as a conference paper at ICLR 2027

Neural Cluster Tree Elimination

Abstract

We introduce Neural Cluster Tree Elimination (NCTE), a method for approximate probabilistic inference over discrete graphical models. The scheme approximates hard-to-compute messages over tree decompositions of the graphical model using neural networks. It extends Neural Bucket Elimination (NeuroBE)—an earlier approach restricted to bucket trees and to the bucket elimination scheme. By merging buckets into clusters, NCTE replaces a long chain of neural approximators with fewer networks, improving efficiency by requiring fewer networks to be trained and boosting accuracy by reducing error accumulation. We provide several strategies for transitioning from a bucket tree to a cluster tree to optimize the tradeoff between time and accuracy. Our empirical evaluation demonstrates the benefits and competitiveness of this approach for computing the partition function of a graphical model.

Primary area:
probabilistic methods (Bayesian methods, variational inference, sampling, UQ, etc.)
Keywords:
probabilistic graphical models, approximate inference, bucket elimination, tree decompositions, neural message approximation, partition function

Reviews

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

In this work the authors extended NeuroBE into a class of neurosymbolic algorithms (NCTE) operating over tree-decompositions. The authors empirically show that the new framework facilitates better performance in time/ accuracy in most of the problem instances tested. The empirical analysis shows that selecting a good tree-decomposition can be obtained by analyzing the problem structure combined with empirical estimation of some performance parameters from data.

Overall Assessment This is a solid systems-style extension paper (of NeuroBE). The core idea is straightforward: (1) NeuroBE trains a neural approximation at every large bucket; (2) NCTE merges buckets into larger clusters, thereby reducing the number of neural approximators and potentially reducing error propagation. The paper demonstrates substantial runtime improvements and often improved accuracy relative to NeuroBE. The empirical results are generally convincing for the specific claim: "Carefully chosen cluster-tree decompositions can outperform bucket-tree decompositions for neural message approximation. "

Critical strengths
  1. Clear technical contribution The contribution is easy to understand: NeuroBE consists of many neural approximators. This is replaced with NCTE, which uses fewer neural approximators via cluster merging. This is conceptually clean and emerges naturally from classical bucket-tree versus cluster-tree elimination theory.

  2. Strong empirical gains The reported runtime improvements are often dramatic. For example: grid20x20f10: no-merge: 50.5 min Reduce-NN: 3.9 min while also reducing error from 3.49→0.255 simultaneously. The paper claims several pedigree instances show similarly large gains.

  3. The tradeoff theory is sensible The paper correctly identifies competing effects: benefits of fewer networks include less training cost, less error accumulation cost; in addition, larger eliminators lead to more expensive sample generation and higher local computational burden. The observed U-shaped runtime curves are consistent with this model.

This is achived via fewer neural approximators via cluster merging. This is conceptually clean and emerges naturally from classical bucket-tree versus cluster-tree elimination theory.

Critical weaknesses
  1. Missing scale-up analysis This is perhaps the largest experimental weakness. The paper includes: grids, pedigrees, RBMs, and larger instances within those classes. However, it never really answers: How does NCTE scale as problem size grows? For example, I expected plots of: n↦"runtime" or n↦"error" variables ranging from 100 to 5000. Instead, we see isolated benchmark points. This is not true scaling analysis.

  2. Almost no ablation study I searched specifically for ablations and found essentially none. The paper compares: no merge, subsumption-only, Reduce-NN; however, these are algorithm variants, not ablations.

Ablations would answer questions such as: Why does error improve? The paper asserts: "fewer neural approximations reduce error accumulation. " But I do not see experiments measuring: error per approximation stage, cumulative message distortion, approximation depth, propagation of local neural errors. The claimed mechanism is never directly tested.

  1. No evidence for the error-propagation hypothesis The paper repeatedly suggests: "fewer NNs → less accumulated error → better accuracy. " But this remains a hypothesis. A convincing experiment would compute: ϵ_t="message error at depth " t along the elimination chain. Then show: ϵ_t grows substantially in NeuroBE but not NCTE. Nothing like this appears.

  2. No architectural ablation All networks appear to use: 2 hidden layers, width 3∣S∣, ReLU. The paper never investigates: network depth, width, activations, sample counts. Consequently it is impossible to know whether: (a) cluster merging is the principal driver, or (b) training budget allocation is.

  3. No sensitivity analysis of the learned approximation The implementation fixes N=O(∣S∣^2 log⁡∣ S∣) samples. Yet there is no analysis of a range of sample bugets, e.g., from 20% to 100%: Therefore we cannot distinguish: Is NCTE robust because (a) clusters are intrinsically better? or (b) because merged networks receive more effective supervision?

What Experiments Are Missing?

A. Number-of-NNs ablation You need to artificially vary K="number of neural approximators" and then measure accuracy and runtime. This would directly test the central hypothesis.

B. Error accumulation study Measure exact message error against exact elimination: ∥λ_t-λ ̂_t∥ at successive levels. Then demonstrate error propagation. Currently the key mechanism is asserted but not shown.

C. Scale-up study For grids: 10×10 20×20 30×30 40×40 50×50 then plot: runtime, accuracy, number of networks, average separator size. The paper lacks this entirely.

D. Separating the two effects Merging changes two things simultaneously: fewer networks and larger eliminators. The paper never disentangles them. A proper ablation would independently vary: (a) number of NNs, (b) eliminator size.

E. Compare against modern neural inference methods The comparison is largely against NeuroBE and indirectly against earlier methods discussed in related work. For an ICLR paper, the audience will likely ask: Why not compare against current neural amortized inference approaches? The evaluation is somewhat narrow.

Theoretical Weakness: The paper's explanatory theory is fairly weak. The central argument is: "fewer neural approximations reduce accumulated approximation error. " But there is no theorem such as: "Error" (T_"cluster" )<"Error" (T_"bucket" ) under reasonable assumptions. Nor is there a bound relating: approximation depth, message error, and final partition-function error. As a result, much of the explanation remains intuitive.

Questions for authors

Q1: Why does accuracy improve? What experimentally measured mechanism causes the improvement? The paper does not answer this convincingly.

Q2: How does performance scale with graph size? I do not see a true scaling study.

Q3: How much of the gain comes from: • fewer NNs, • larger separators, • larger training sets, • different sample distributions? There is no ablation answering this.

Q4: Can the claimed error-propagation effect be measured directly? No experiment currently appears to do this.

3 comments
AuthorsOpenReview ↗

Response to Reviewer XQAd

Summary. We thank the reviewer for identifying several useful empirical questions. The revision adds a controlled scale-up study, controlled clustering comparisons, a direct local message-error study, and narrows the accuracy claims to what is empirically supported.

Scale-up analysis / Experiment C / Q2. We added a controlled 28×N Ising-grid study spanning 112 to 5,600 variables. Exact ZZ is computed by cluster tree elimination, while every approximate method uses the same width-28 ordering, holding induced width fixed while measuring exact-reference error, runtime, and number of learned messages.

Changes.

  • Scaling design: Section 4.2, pp. 9–10; scaling table: Appendix H, Table 7, p. 25.

Ablation study / Experiments A and D / Q1. The reviewer asks to independently vary the number of neural approximations and eliminator size. In NCTE these are structurally coupled: reducing learned messages requires merging clusters, which necessarily changes the eliminator. We therefore compare three clustering strategies while holding architecture, loss, sampling policy, and elimination order fixed, and sweep emax⁡e_{\max} to vary merging. On grid20x20.f5 and 38 of pedigree19’s 82 network clusters, the merged message has mean absolute local error 0.101 and 0.069, versus 0.192 and 0.145 for the summed magnitudes of the two learned messages it replaces. When a merge makes a message exactly computable, that approximation error disappears.

Changes.

  • Controlled comparisons: Section 4.1, p. 7; local-error study: Section 4.2, pp. 8–9 and Appendix G, pp. 22–24 (Table 6 p. 23; Figure 10 p. 24).

Error-propagation hypothesis / Experiment B / Q4. We added an experiment measuring each learned message’s local contribution under exact surroundings. One merged approximation typically replaces two local error sources without inheriting their combined magnitude. We do not present this as a telescoping decomposition of the full NCTE run or proof of reduced propagation.

Changes.

  • Isolated local-error analysis and limitations: Section 4.2, pp. 8–9; Appendix G, pp. 22–24. The paper states that this is not an in-context decomposition and does not guarantee every merge improves accuracy.

Architecture and sample sensitivity / Q3. We use the same neural-network architecture rule, loss, uniform sampling policy, and sample-count rule for all clustering strategies, and do not reallocate computation saved by merging to increase capacity or sampling. Because merging can change separator sizes, resulting network widths and training-sample counts can change under these fixed rules. Thus, we evaluate clustering strategies under a common training protocol; we do not claim the gains are independent of architecture or sample count.

Change.

  • Added this control statement to Section 4.1, p. 7.

Experiment E. Comparison with modern neural inference methods. We did not identify a directly comparable baseline. For example, Belief Propagation Neural Networks (BPNNs) learn an inference procedure across a distribution of graphical models using training instances with known partition functions, while neural variational/autoregressive methods learn a global distribution or direct estimate of ZZ. NCTE instead trains instance-specific approximations of local elimination messages, yielding a reusable message-based representation. To broaden the direct comparison, we added WMB with moment matching and weight optimization at i-bound 20; across the 19 exact-reference configurations, Reduce-NN has lower mean absolute log⁡10Z\log_{10} Z error (0.490 vs. 2.66), at higher mean runtime (11.6 vs. 7.1 minutes).

Change.

  • WMB protocol/results: Section 4.1, p. 7; Table 1, p. 9; Section 4.2, p. 8.

Theoretical weakness. Accuracy explanation. Our formal analysis addresses runtime only; we do not have a theoretical result showing merging reduces partition-function error. The explanation that reducing neural approximations may reduce accumulated error is therefore an empirical hypothesis. We examine it across the full emax⁡e_{\max} sweep in Appendix D, Table 3 (pp. 19–20), which reports error, NN count, error per NN, and runtime, and more directly in the local-error study in Section 4.2 (pp. 8–9) and Appendix G (pp. 22–24). These results provide empirical evidence, not a theoretical guarantee.

Changes.

  • Abstract/Introduction now state the accuracy claim empirically.
  • Full emax⁡e_{\max} sweep: Appendix D, Table 3, pp. 19–20; local-error caveats: Section 4.2, pp. 8–9 and Appendix G, pp. 22–24 (Table 6 p. 23; Figure 10 p. 24).
Reviewer_XQAdOpenReview ↗

response to authors' rebuttal

Thanks to the authors for addressing my concerns about the experimental issues, such as scale-up and ablation studies. These are helpful to the ML audience.

I have a nagging issue with this response, based on a comment originally in my review: ML researchers are interested in "why" a phenomenon occurs; the increased empirical analysis helps to address this, but the rebuttal has not satisfied this issue properly. There is now significantly more empirical data, but what does this data point to? How can you use this data to improve tree decomposition in general? I still seem to be missing the overall conclusion. Without a true discussion of the outcome of the empirical analysis, I cannot improve my score.

Thank you. To answer the “why?”: when merging, we perform more exact computation (via more expensive variable elimination) in order to decrease the number of neural networks, and we hypothesize that this decrease lowers average log Z error. Merges either replace an NN approximation and exact message with an exact message or replace two NN approximations with one. In the latter case, the merged cluster’s message inherits the dimensionality of the parent’s message, motivating the expectation of comparable error per NN. Our local error study isolates this case of two NN-approximations merging into one. We find roughly stable average error per NN, i.e. more merging does not generally increase the per-NN error. Additionally, the merge-bound sweeps support the overall accuracy trend: tree decompositions with fewer neural approximations generally yield lower partition function error.

We have made the hypothesis, supporting evidence, and implications for tree-decomposition design explicit in Section 4.2 and the conclusion.

Changes:

  • Section 4.2, “Local approximation error under merging”: clarified that the merged cluster inherits the parent’s separator.
  • Section 4.2, “Implications for tree-decomposition design”: connected the local error study to the implications for tree-decomposition design.
  • Section 5, “Summary and Conclusion”: summarized the implications for tree-decomposition design.
  • Section 4.2, “Scaling with problem size,” and Appendix H, Table 7: added the completed results of the 28×N scaling study, with three runs per instance.
Reviewer_pm27OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper extends Neural Bucket Elimination to cluster-tree decompositions. Rather than training a neural approximation for each high-width bucket message, it merges adjacent buckets and learns fewer outgoing cluster messages. This reduces the number of learned approximations but increases the cost of generating each training target, since multiple variables must be marginalized simultaneously.

The authors introduce subsumption-only merging and a more permissive Reduce-NN heuristic, controlled by an eliminator budget. Experiments on grid, pedigree, and RBM instances report substantial runtime reductions and generally improved partition-function estimates relative to a no-merging implementation.

Critical strengths

1. The computational motivation is clear and compelling. Reducing the number of sequentially trained neural messages directly addresses a major overhead of the original approach.

2.The experiments demonstrate substantial improvements over the immediate baseline. Table 1 reports large reductions in network count and runtime across the tested configurations. Accuracy also improves on most instances with exact references.

3.The runtime tradeoff is explicitly investigated. Sweeping the eliminator budget reveals the expected transition from training-dominated to sample-generation-dominated computation.

4.The shared implementation improves internal comparison fairness. Reimplementing the no-merging baseline in the same codebase reduces an important source of implementation confounding.

Critical weaknesses

W1.The evaluation establishes an improvement over NeuroBE, but not broader competitiveness. The main experiments compare three clustering strategies within one framework. There are no direct contemporary comparisons with weighted mini-bucket, sampling-based estimators, or other partition-function methods under matched resources. The competitiveness of an earlier NeuroBE evaluation does not establish the competitiveness of the present implementation and benchmark setting.

W2.The explanation based on reduced error accumulation remains largely qualitative. Fewer approximators do not necessarily imply smaller error, as the RBM results themselves demonstrate. Merging also changes separator dimensionality, training targets, sample counts, and approximation difficulty. A direct message-error or propagation analysis would better support the claimed mechanism.

W3.The complexity model abstracts away important neural evaluation costs. Treating neural-message evaluations as constant-time operations obscures their dependence on separator size, network width, and the number of incoming neural messages. The empirical cost model is useful, but its hardware- and cluster-dependent constants limit its predictive interpretation.

W4.Uncertainty and parameter-selection evidence are insufficient. Results are averaged over three seeds without dispersion estimates. The highlighted emax=14e_{max}=14 is selected using aggregate runtime on the evaluated configurations. A held-out selection protocol would better demonstrate that the proposed cost model predicts useful settings rather than explaining them retrospectively.

W5.Several numerical and implementation details need clarification. The factor representation permits zeros, while training uses log-message targets. The handling of zero targets is not specified. In addition, the grid10x10f10 Reduce-NN configuration trains no neural network but reports a nonzero error of 0.0042. This may reflect reference precision or numerical handling, but requires explanation.

Questions for authors

Q1. How does NCTE compare with strong non-neural partition-function estimators under matched runtime and memory?

Q2. Can the authors separate runtime into target generation, neural fitting, neural evaluation, and exact-message computation?

Q3. How are zero-valued messages and hard constraints handled in the log-space training loss?

Q4. Why does the configuration with zero neural approximations retain a nonzero partition-function error?

Q5. Does the estimated merge threshold predict the best runtime on held-out instances or different hardware?

Q6. How robust are the improvements to elimination ordering and variable-domain heterogeneity?

4 comments
AuthorsOpenReview ↗

Response to Reviewer pm27

Summary. We thank the reviewer for the detailed comments. The revision adds a WMB baseline, a local message-error study, seed variability and runtime-breakdown tables, and clarifies the emax⁡e_{\max} heuristic and numerical preprocessing.

W1 / Q1. Broader competitiveness. We added WMB with moment matching and weight optimization at i-bound 20; higher i-bounds were infeasible under our memory limit. Across the 19 exact-reference configurations, Reduce-NN has lower mean absolute error than WMB (0.490 vs. 2.66), at higher mean runtime (11.6 vs. 7.1 min). WMB has lower error on four and ties on one up to rounding, showing an accuracy-runtime trade-off rather than uniform dominance. Our primary comparison is with message-passing schemes because they compile reusable messages for subsequent marginal queries; we do not claim superiority over sampling-based estimators.

Changes.

  • WMB protocol: Section 4.1, p. 7.
  • WMB results: Table 1, p. 9; Section 4.2, p. 8.

W2. Reduced error accumulation. Our theory concerns computational cost; we do not claim merging is guaranteed to reduce approximation error. We added a five-seed local message-error study on grid20x20.f5 and a subset of pedigree19. For 99 and 33 merges replacing two learned messages with one, networks are scored with exact incoming and backward messages. Mean absolute local error is 0.101 vs. 0.192 for the summed constituent magnitudes on the grid, and 0.069 vs. 0.145 on pedigree19. This is isolated local-error evidence, not an in-context decomposition, and does not imply every merge improves accuracy.

Changes.

  • Local-error results: Section 4.2, pp. 8-9; methodology/caveats: Appendix G, pp. 22-24.
  • Abstract/Introduction now state the accuracy result empirically rather than as a theoretical consequence.

W3 / Q2. Complexity model and runtime decomposition. Section 3.1 models the main trade-off as T(C)≈N(γgenke+γNN)T(C)\approx N(\gamma_{\mathrm{gen}}k^e+\gamma_{\mathrm{NN}}). γgen\gamma_{\mathrm{gen}} includes sample generation and neural-factor evaluation and is calibrated empirically because it depends on the cluster and hardware. We also report measured time in exact-message computation, sample/target generation, NN training, and other overhead. Neural-message evaluation is included in the first two categories where it occurs, not separately instrumented.

Changes.

  • Calibration/scope: Section 3.1, p. 6; derivation: Appendix B, p. 13.
  • Runtime breakdown: Appendix F, Table 5, p. 22.

W4 / Q5. Uncertainty and parameter selection. Appendix E, Table 4 (p. 21) reports mean ± sample SD across three seeds. The observed runtime minimum near emax⁡=14e_{\max}=14 is consistent with the modeled training-vs.-sample-generation trade-off, but is not held-out validation. We have not tested predictive accuracy on new hardware/instances and do not claim 14 is universal.

W5 / Q3 / Q4. Numerical details and zero-valued factors. Zero-valued entries occur only in pedigrees; before elimination we replace them with ϵ=10−5\epsilon=10^{-5} so log-space messages/targets remain finite. For grid10x10.f10 under Reduce-NN, no neural approximation is used. The remaining 0.0042 discrepancy is numerical, primarily rounding of the published reference (303.09 vs. 303.0860), and is unrelated to ϵ\epsilon.

Changes.

  • Preprocessing and zero-network/reference explanation: Section 4.1, p. 7.

Q6. Elimination ordering and heterogeneous domains. All methods use the same elimination ordering per instance. Pedigrees have heterogeneous domain sizes, where NCTE retains its advantage; we have not separately studied sensitivity to alternative orderings or domain-size distributions.

Change. Elimination-ordering protocol: Section 4.1, p. 7.

Dear Reviewer,

Thank you again for your great work on reviewing this paper submission to ICLR 2027.

The authors have now submitted their rebuttal. The open reviewer-author discussion phase will end soon, on November 18 at 11:59 PM AoE.

Please read the authors' responses, determine whether any further clarification is needed, and respond to the rebuttal at your earliest convenience. Please be sure to acknowledge the authors' responses and update your review accordingly.

Best regards, Your AC

Dear Reviewer pm27,

Thank you again for your thoughtful review. We would appreciate hearing whether our response and the manuscript revisions address your concerns. Are there any remaining issues or points that would benefit from further clarification? We would be happy to address them.

Best regards, The authors

Thank you for your response. After careful consideration, I believe my initial evaluation is fair and reasonable, so I will keep my score unchanged.

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

The paper introduces Neural Cluster Tree Elimination (NCTE) for approximating the partition function of discrete graphical models / methods. NCTE expands NeuroBE by merging adjacent buckets into clusters, replacing multiple neural message approximations with fewer approximations over larger elimination blocks. The paper proposes subsumption-only and reduce-NN merging methods and analyzes the trade-off between reduced network-training costs and increased sampled-generation rates.

Critical strengths
  • The method addresses a clear computational bottleneck and approaches it nicely. Instead of playing around NN structures on top of existing work (i.e., NeuroBE), the authors reconsider where neural approximation should occur within elimination. Merging can remove intermediate training problems, while the elimination budge controls the additional cost of generating each training budget. I find this quite a sensible extension, and the cost analysis later on helps explain why aggressive merging eventually becomes counter-productive.
  • The improvements over baseline setups seem quite significant. The experiments are well-structured.
Critical weaknesses
  • The comparison does not directly provide / prove NCTE's competitiveness under broader settings. The experiments compare no merging with two merging strategies, so they primarily give an improvement within NeuroBE framework. Direct comparisons between weighted mini-buckets elimination or sampling-based estimators under comparable budgets will be appreciated. Referring NeuroBE's earlier results does not fully give the position of NCTE under the current experiment setup.
  • Selecting the merging budget feels less direct compared to the benefit of merging itself. It is not that clear how reliably the proposed methods selects a good budget for a new instance, altho tab1 shows e_max=14 gives the lowest aggregate runtime and Sec3.1 talks about a useful cost-based estimate. I believe it assume equal sample counts and uses training cost over the full epoch budget, whereas the implementation uses early stopping?
Questions for authors

See weakness, and more concretely:

Q1: How does NCTE compare with weighted mini-bucket elimination and a strong sampling-based estimator under comparable runtime and memory budgets?

Q2: Can the proposed cost model select e_max before running the full parameter sweep, and how close is its choice to the best observed acc-runtime trade-off on held-out substances?

1 comment
AuthorsOpenReview ↗

Response to Reviewer qgEK

Summary. We thank the reviewer for the constructive review. In the revision we add a direct WMB comparison and clarify how emax⁡e_{\max} is selected, calibrated, and interpreted.

Critical weakness / Q1. Broader competitiveness. Regarding mini-bucket elimination, we now compare against WMB with moment matching and weight optimization at i-bound 20; higher i-bounds were not feasible under our memory limit. The results show (Table 1 and Section 4.2) that across the 19 configurations with exact references, Reduce-NN has lower mean absolute error than WMB (0.490 vs. 2.66), at higher mean runtime (11.6 vs. 7.1 minutes). WMB has lower error on four configurations and ties on one up to rounding, showing an accuracy–runtime trade-off rather than uniform dominance.

Regarding sampling methods, our primary comparison is with message-passing schemes because they can be viewed as compilation methods: once approximate messages are computed, many marginal queries conditioned on evidence can be answered on the augmented tree decomposition with minimal re-derivation. Thus, we make no claim of superiority over sampling-based estimators.

Changes.

  • Added the WMB protocol to Section 4.1, p. 7.
  • Added WMB to Table 1 (p. 9) and the direct accuracy/runtime comparison to Section 4.2 (p. 8).

Critical weakness / Q2. Selecting emax⁡e_{\max}. Yes. The cost model can suggest a fixed emax⁡e_{\max} before a full sweep once its timing constants are calibrated on the target hardware. As derived in Section 3.1, emax⁡∗=log⁡k(γNN/γgen)e^*_{\max}=\log_k(\gamma_{\mathrm{NN}}/\gamma_{\mathrm{gen}}); for binary variables this becomes log⁡2(γNN/γgen)\log_2(\gamma_{\mathrm{NN}}/\gamma_{\mathrm{gen}}). We estimate γNN\gamma_{\mathrm{NN}} by timing NN training per sample over the epoch budget and γgen\gamma_{\mathrm{gen}} by timing one joint-cluster evaluation during target generation, including incoming NN evaluations. On our hardware the resulting heuristic gives approximately emax⁡=14e_{\max}=14, near the observed aggregate runtime minimum. However, the implementation uses separator-dependent numbers of samples and early stopping, and the analysis was developed alongside the sweep, so this agreement is retrospective consistency rather than held-out predictive validation. The rule aims to improve the runtime only.

Changes.

  • Added the calibration procedure to Section 3.1, “Selecting a good emax⁡e_{\max},” p. 6, with the derivation in Appendix B, p. 13.
  • Clarified in Section 3.1, p. 6, that the rule is a practical fixed-emax⁡e_{\max} heuristic rather than an optimal merge policy and that its agreement with emax⁡≈14e_{\max}\approx14 is not obtained by held-out validation.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.