Pith. sign in

REVIEW 3 major objections 6 minor 1 cited by

Architecture-Aware Learning Curve Extrapolation via Graph Ordinary Differential Equation

T0 review · 3 major / 6 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read By encoding a network's architecture as a graph and feeding its embedding into a latent ODE, LC-GODE extrapolates learning curves from ten epochs and cuts error by 20–65% relative to architecture-blind models.

desk verdict A credible, workmanlike paper that pulls architecture information into latent neural ODEs for learning curve extrapolation; the main gains look real, but missing error bars and a few sloppy details keep it short of a clean accept. read the letter →

arxiv 2412.15554 v3 pith:HIBXQFIE submitted 2024-12-20 cs.LG cs.AIstat.ML

Yanna Ding , Zijie Huang , Xiao Shou , Yihang Guo , Yizhou Sun , Jianxi Gao This is my paper · ORCID
classification cs.LGcs.AIstat.ML
keywords learningcurveextrapolationneuralarchitecturesearchordinarydifferentialequationsgraphnetworksvariationalautoencodermodelselectionAutoML
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper asks whether a neural network's architecture carries useful signal for predicting its own learning curve, and answers yes: if the architecture is turned into a graph (neurons or feature maps as nodes, normalized in/out degrees as node features, operation type as edge weight), a graph embedding can be fed into the vector field of a latent ordinary differential equation that extrapolates the curve from the first 10 epochs. The reason this matters is practical: curve extrapolation drives early stopping, hyperparameter tuning, and neural architecture search, and existing methods model curves in isolation, so any architecture-aware signal is a potential free predictor. On four benchmarks spanning tabular MLPs and image CNNs, the architecture-conditioned model reduces extrapolation error by 20 to 65 percent compared to the same latent-ODE model without architecture information, and it improves the ranking of configurations in model selection. The paper's claim is that the loss landscape differs by architecture, and a low-dimensional graph embedding of that architecture is enough to modulate the ODE that traces the curve.

What carries the argument

LC-GODE (Learning Curve Graph ODE) is an architecture-conditioned latent neural ODE. Its central object is the equation $\dot z = f_{\theta_2}([z \| z_G])$, where $z_G$ is a graph-level embedding of the network architecture and $z$ is a low-dimensional latent state encoding the learning curve's current position. The architecture encoder builds $z_G$ from a cell-based graph representation (nodes are neurons or feature maps, node features are normalized in/out degrees, edge weights encode operation types) using GCN message passing followed by a pooling layer, and the ODE is integrated numerically with a Runge-Kutta solver so the model can query any future time step. The graph embedding modulates the vector field at every integration step, which is how architectural structure influences the predicted trajectory.

What would settle it

Shuffle the graph embeddings: train the model with $z_G$ permuted across architectures (or replaced by a random vector of the same dimension) while keeping all other components identical; if extrapolation error does not rise materially on the held-out set, the claimed architecture signal is not what drives the improvement. A complementary check is cross-space transfer: train on NAS-Bench-201 cell graphs and extrapolate curves for a different cell-based search space; if the 20–65% error reductions vanish, the cell graph is benchmark-specific rather than a general architecture code.

Watch

Extended reading notes

Core claim

The paper's central claim is that the evolution of a learning curve can be modeled as an autonomous latent ODE whose right-hand side depends on the architecture: $\dot z = f_{\theta_2}([z \| z_G])$. Here $z_G$ is produced by an architecture encoder that runs GCN message passing on the cell graph and pools to one vector, while the latent state $z$ is initialized from a variational posterior $q_{\phi}(z_{n+1} | \{y_i,t_i\}_{i=1}^n)$ computed by a GRU over observed epochs. The decoder maps each integrated latent state to $\hat y_i$, and the whole system is trained by maximizing the ELBO. Empirically the paper reports that this joint model beats six baselines, including Bayesian methods and latent NODE/NSDE without architecture, on test accuracy and test loss curves, and that including architecture raises the correlation between initial latent distance and final performance difference from 0.77 to 0.83 on CIFAR-10.

Load-bearing premise

The load-bearing premise is that a coarse graph of the architecture—four nodes in a repeated cell, normalized in/out degrees, and operation-type edges—preserves enough of the architecture's effect on the loss landscape to steer the latent ODE correctly for unseen architectures.

Editorial extensions

If this is right

  • On the paper's four benchmarks, conditioning the latent ODE on the architecture embedding reduces test-accuracy extrapolation error by 36.13%, 30.72%, 34.97%, and 59.63% and test-loss error by 65.5%, 44.61%, 20.1%, and 23.45% relative to the same model without architecture information.
  • All the model needs is the first 10 epochs and the architecture graph; it can then forecast the remaining 190 epochs, which makes it usable for early stopping and for ranking configurations before full training.
  • Because the ODE evolves a low-dimensional latent state, the runtime of the forward pass is $O(D^2 T)$ and independent of the network's total size, so prediction cost does not grow with the architecture.
  • Including architecture information raises the correlation between initial latent-state distance and final performance difference from 0.77 to 0.83 on CIFAR-10, and the predicted best configuration ranks 3–8 positions better on segment and CIFAR-10 with regret reduced by up to 96%.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper varies hyperparameters such as learning rate, batch size, and weight decay when generating MLP trials but does not feed them into the ODE; conditioning the same dynamics on a configuration embedding alongside $z_G$ is a direct way to test how much of the remaining error is optimization-settings-driven rather than topology-driven.
  • Because the CNN representation is a repeated four-node cell, a strong test of generality is whether the learned $z_G$ transfers to a different cell-based search space; if it does not, the improvement may be a benchmark-specific encoding rather than a general architecture signal.
  • The reported 20x model-selection speedup is computed from ten observed epochs and near-zero inference latency; for settings requiring longer observations or where curves are noisy, the speedup and ranking gains would need to be recomputed rather than assumed.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 6 minor

Summary. The paper introduces LC-GODE, a latent neural ODE model for learning-curve extrapolation in which the drift function is conditioned on a graph embedding of the neural network architecture. The architecture is encoded with GCN layers and a pooling mechanism, the observed early epochs are processed by a GRU-based variational encoder, and the future curve is decoded from the integrated latent state. Experiments are conducted per source task on two OpenML MLP tasks (car, segment) and two NAS-Bench-201 CNN tasks (CIFAR-10, CIFAR-100), with comparisons against six baselines, an ablation study, and a model-ranking analysis. The central claim is that architecture-conditioned ODE extrapolation outperforms all baselines on all four datasets and improves early model selection.

Significance. Architecture-aware learning-curve extrapolation is a timely and relevant topic for AutoML and NAS, and the idea of modulating the latent ODE with a graph-derived embedding is clearly presented and well motivated. The experimental protocol is generally sound: per-task training, held-out architectures, and matched sequence encoders and decoders for the NODE and NSDE ablations, with code and public benchmarks provided. If the reported gains are robust, the method offers a practical 10-epoch tool for model selection with substantial speedups. However, the significance of the empirical contribution depends on the stability of the reported margins, which is not yet established because no seed variation, error bars, or significance tests are reported anywhere in the paper. I agree with the reader's assessment that the design is not circular: architecture embeddings are computed from graphs, not from target curves, and held-out architectures are used for evaluation.

major comments (3)
  1. [Tables I, II, VI; Figs. 3, 5, 6] All reported results are single point estimates without error bars, number of seeds, or significance tests. This is load-bearing because the central comparative claim in Section IV-A(c) relies on several small margins: on CIFAR-10 test loss, LC-GODE's MAPE is 0.1487 versus 0.1518 for NSDE at 80 epochs and 0.1629 versus 0.1639 at 200 epochs (Table VI); on segment test loss at 200 epochs, LC-GODE (0.0925) barely beats LC-PFN (0.0937). The abstract's statement that the model quantifies uncertainty through variational parameters is also not evaluated: no predictive intervals, calibration curves, or coverage numbers are reported. Please report mean and standard deviation over at least three to five random seeds and a paired significance test such as Wilcoxon signed-rank or a bootstrap interval for Tables I, II, and VI and for Figures 3, 5, and 6, and discuss the calibration of the predictive distribution.
  2. [§IV-A(d), Table II] The claim that LC-GODE 'reduces regret by 96% on CIFAR-10 compared to the superior baseline among NODE and NSDE for test accuracy curves' is not supported by Table II. For CIFAR-10 test accuracy, NODE's regret is 0.0025, NSDE's regret is 0.0101, and LC-GODE's regret is 0.0004; the reduction relative to NODE, which is the superior baseline, is 84%, not 96%. The 96% figure corresponds to comparison with the inferior baseline NSDE. Please correct the percentage or state the comparison baseline explicitly, and provide paired differences for the regret and ranking metrics.
  3. [§IV-A(c), §III-B(c), Eq. (9)] The sentence 'This improvement is due to the incorporation of architecture information with graph embedding' is an attribution claim that is not directly established by the experiments. LC-GODE differs from NODE and NSDE not only in receiving architecture information but also in that Eq. (9) concatenates z and zG, doubling the input dimension of the ODE function, and in having an additional graph encoder with its own parameters. Without a capacity-matched control, for example a NODE or NSDE variant that receives a random or fixed architecture embedding of the same dimension, or architecture information delivered as a flat feature vector, the observed gains could in principle reflect additional model capacity rather than the graph representation. Please add such an ablation or soften the causal attribution.
minor comments (6)
  1. [Appendix A, Metrics] Equation (13) defines speedup with 'Runtime for SGD over 52 Epochs' in the numerator, but the experiments train for 200 epochs according to Section IV-A and Appendix A; please reconcile this with the claimed 20x speedup in Section IV-A(d).
  2. [Appendix Table V] The hyperparameter table states Condition Length 20% Tmax and Prediction Length 80% Tmax, while Section IV-A fixes the condition length at 10 epochs; under the mapping t_i = i Tmax/m, 20% of Tmax would correspond to 40 epochs, so the relationship between these settings needs clarification.
  3. [Appendix A, Metrics] The citation placeholders '[?]' and '[NasWOT]' should be resolved to actual references before publication.
  4. [Appendix A, Datasets] The sentence 'We discard runs The parameters randomly sampled include ...' is incomplete; the intended discarding rule is missing.
  5. [§III-B(b), Eq. (7)] For directed CNN graphs, the GCN update uses the same degree matrix on both sides of the adjacency matrix; please clarify whether the adjacency matrix is symmetrized before normalization and how the integer edge weights for operation types enter the message passing.
  6. [Various] Minor typographical issues should be corrected: 'fomulated' in Section III-B(d), 'comuted' in Appendix A(b), and 'the the wall-clock time' in Appendix A(e).

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the architecture embedding is derived from the graph, the future curve is predicted from observed epochs through a trained latent ODE, and the claimed gain is evaluated against the graph-free NODE/NSDE variants on held-out curves.

full rationale

The prediction chain in Eqs. (1)-(9) is self-contained: the sequence encoder maps the observed epochs y1..yn to a latent initial condition, the graph encoder maps the architecture to zG, and the ODE in Eq. (9) evolves the latent state using [z||zG]. The target future values yn+1..ym enter only through the training objective (Eq. 10), never through the architecture embedding or the extrapolation mechanism, so there is no fitted-input-called-prediction pattern. The comparison against NODE, described as 'Latent Ordinary Differential Equations, focusing primarily on modeling the latent loss representation without incorporating architectural information' and trained with the same variational framework, is a genuine ablation of the architecture-conditioning contribution rather than a prediction that is forced by construction. Self-citations to prior latent-ODE and graph-ODE work (Huang et al. 2020, 2021; Rubanova et al. 2019) supply reusable building blocks, but the central claim of this paper is the empirical comparison of LC-GODE to baselines on held-out curves, which does not reduce to those citations. The absence of error bars or seed variance is a reproducibility and statistical-support concern, not circularity. No step in the derivation renames a known result or imports a uniqueness theorem from the authors' prior work.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The central claim is empirical, so the ledger records the modeling assumptions and hyperparameters the extrapolation depends on, rather than physical constants. The paper offers no derivation of the latent ODE's form; it is justified by test performance.

free parameters (5)
  • Latent dimension D = 16
    Set as a hyperparameter, not fitted to the target result. Table V reports D=16 for all runs.
  • Maximal continuous time Tmax = variant (2.5 to 10)
    Hyperparameter swept in Figure 6; larger Tmax hurts performance. It is not a fitted constant for the central claim.
  • Condition length n (observed epochs) = 10
    Chosen as 10 epochs in Section IV-A, though Table V lists 20% of Tmax, creating an inconsistency.
  • Number of GCN layers = 2
    Used in the instantiated architecture encoder as reported in Section IV-A.
  • ODE function MLP layers = 2
    Used for the drift network in the reported instantiation.
assumptions (5)
  • domain assumption Gradient descent with small step size approximates continuous-time gradient flow dTheta/dt = -partial L / partial Theta (Su et al. 2016).
    Invoked in Section III-C to justify the ODE formulation, though the exact ground-truth ODE is not used.
  • ad hoc to paper A single latent ODE f_theta2([z||zG]) can represent the evolution of loss curves for all architectures in a given source task.
    Eq. (9) is the central modeling assumption; it is not derived and its validity is only tested empirically.
  • domain assumption The variational posterior q_phi(z_{n+1} | {y_i, t_i}) is Gaussian with diagonal covariance.
    Eq. (4) states the Gaussian posterior, a standard VAE assumption.
  • domain assumption Test architectures are drawn from the same distribution, meaning the same source task and training protocol, as training architectures.
    The method is trained per source task; generalization is only claimed within the same benchmark task.
  • standard math Graph pooling (DiffPool) produces a permutation-invariant graph embedding zG.
    Used in Eq. (6) and the associated pooling; consistency across permuted node orderings is assumed.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Architecture-Aware Learning Curve Extrapolation via Graph Ordinary Differential Equation." pith.science (2026). https://pith.science/paper/HIBXQFIE

@misc{pith2026241215554,
  author       = {Pith},
  title        = {Pith review of: Architecture-Aware Learning Curve Extrapolation via Graph Ordinary Differential Equation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HIBXQFIE}},
  note         = {Machine review of arXiv:2412.15554}
}
read the original abstract

Learning curve extrapolation predicts neural network performance from early training epochs and has been applied to accelerate AutoML, facilitating hyperparameter tuning and neural architecture search. However, existing methods typically model the evolution of learning curves in isolation, neglecting the impact of neural network (NN) architectures, which influence the loss landscape and learning trajectories. In this work, we explore whether incorporating neural network architecture improves learning curve modeling and how to effectively integrate this architectural information. Motivated by the dynamical system view of optimization, we propose a novel architecture-aware neural differential equation model to forecast learning curves continuously. We empirically demonstrate its ability to capture the general trend of fluctuating learning curves while quantifying uncertainty through variational parameters. Our model outperforms current state-of-the-art learning curve extrapolation methods and pure time-series modeling approaches for both MLP and CNN-based learning curves. Additionally, we explore the applicability of our method in Neural Architecture Search scenarios, such as training configuration ranking.

Figures

Figures reproduced from arXiv: 2412.15554 by the authors.

Figure 1
Figure 1. Overall framework. (a) Given fixed training data and a specific task, each architecture defines a unique loss landscape. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. (a) Graph embedding projections. (b) Pairwise initial [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 4
Figure 4. True vs predicted best test accuracy for car, segment, [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figures from the paper (2 more)
Figure 5
Figure 5. Figure 5: Ablation study for encoders. 2.5 5.0 7.5 10.0 Tmax 0.0 0.2 0.4 0.6 0.8 1.0 1.2 MAPE car segment cifar10 cifar100 10 20 30 40 50 Observation Length 0.0 0.1 0.2 0.3 0.4 20 30 40 50 Latent Dimension 0.1 0.2 0.3 0.4 [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Hyperparameter sensitivity study. We explore three variations for each of the following components: the message passing mechanism, graph pooling, and time series encoder. The message passing mechanisms include GCN (Kipf and Welling, 2016), Graph Attention Networks (GAT…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. NNGPT: Rethinking AutoML with Large Language Models

    cs.AI 2025-11 conditional novelty 5.0 of 10

    NNGPT is an LLM-driven AutoML system that generates executable PyTorch pipelines from a prompt and continuously fine-tunes itself on the results.

Reference graph

Works this paper leans on

22 extracted references · 12 canonical work pages · cited by 1 Pith paper

  1. [1]

    These values are then mapped back to their original space using the inverse of the normalization function

    LC-PFN takes as input the normalized observations and outputs inferred loss values. These values are then mapped back to their original space using the inverse of the normalization function. The parameters of the normalization function are defined as λ = (minimize, lhard, uhard, lsoft, usoft): • min?: A Boolean indicating whether the curve is to be minimi...

    work page 2018

  2. [5]

    A Variational-Sequential Graph Autoencoder for Neural Architecture Performance Prediction

    D. Friede, J. Lukasik, H. Stuckenschmidt, and M. Keu- per, “A variational-sequential graph autoencoder for neu- ral architecture performance prediction,” arXiv preprint arXiv:1912.05317,

    work page Pith review arXiv 1912

  3. [6]

    Neural predictor for neural architecture search,

    W. Wen, H. Liu, Y . Chen, H. Li, G. Bender, and P.-J. Kinder- mans, “Neural predictor for neural architecture search,” in European conference on computer vision . Springer, 2020, pp. 660–676. Y . Tang, Y . Wang, Y . Xu, H. Chen, B. Shi, C. Xu, C. Xu, Q. Tian, and C. Xu, “A semi-supervised assessor of neural architectures,” in proceedings of the IEEE/CVF c...

    work page 2020

  4. [8]

    Nas-bench-301 and the case for surrogate benchmarks for neural architecture search,

    J. Siems, L. Zimmer, A. Zela, J. Lukasik, M. Keuper, and F. Hutter, “Nas-bench-301 and the case for surrogate benchmarks for neural architecture search,” arXiv preprint arXiv:2008.09777, vol. 4, p. 14,

    arXiv 2008

  5. [10]

    Neural ordinary differential equations,

    [Online]. Available: http://papers.nips.cc/paper files/paper/2023/hash/ 0569458210c88d8db2985799da830d27-Abstract-Conference. html R. T. Chen, Y . Rubanova, J. Bettencourt, and D. K. Duvenaud, “Neural ordinary differential equations,” Advances in neural information processing systems , vol. 31,

    work page 2023

  6. [12]

    Speeding up hyper- parameter optimization by extrapolation of learning curves using previous builds,

    A. Chandrashekaran and I. R. Lane, “Speeding up hyper- parameter optimization by extrapolation of learning curves using previous builds,” in Machine Learning and Knowl- edge Discovery in Databases: European Conference, ECML PKDD 2017, Skopje, Macedonia, September 18–22, 2017, Proceedings, Part I 10 . Springer, 2017, pp. 477–492. R. Ru, C. Lyle, L. Schut, ...

    work page 2017

  7. [14]

    Coupled graph ode for learning interacting system dynamics,

    ——, “Coupled graph ode for learning interacting system dynamics,” in Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining, 2021, pp. 705–715. X. Luo, J. Yuan, Z. Huang, H. Jiang, Y . Qin, W. Ju, M. Zhang, and Y . Sun, “Hope: High-order graph ode for modeling interacting dynamics,”

    work page 2021

  8. [15]

    Causal graph ode: Con- tinuous treatment effect modeling in multi-agent dynamical systems,

    Z. Huang, J. Hwang, J. Zhang, J. Baik, W. Zhang, D. Wodarz, Y . Sun, Q. Gu, and W. Wang, “Causal graph ode: Con- tinuous treatment effect modeling in multi-agent dynamical systems,” in Proceedings of the ACM Web Conference 2024, ser. WWW ’24, 2024, p. 4607–4617. J. Vanschoren, J. N. Van Rijn, B. Bischl, and L. Torgo, “Openml: networked science in machine ...

    work page 2024

Show all 22 references
  1. [17]

    Darts: Differentiable ar- chitecture search,

    H. Liu, K. Simonyan, and Y . Yang, “Darts: Differentiable ar- chitecture search,” arXiv preprint arXiv:1806.09055 ,

    arXiv

  2. [19]

    Heterogeneous graph transformer,

    Z. Hu, Y . Dong, K. Wang, and Y . Sun, “Heterogeneous graph transformer,” in Proceedings of the web conference 2020 , 2020, pp. 2704–2710. R. Dey and F. M. Salem, “Gate-variants of gated recurrent unit (gru) neural networks,” in 2017 IEEE 60th international midwest symposium o...

    2020 arXiv

  3. [20]

    as detailed in Table IV. We adhere to the standard procedure outlined in LCBench (Zimmer et al., 2021), with the exception that we introduce variability by randomly sampling the number of hidden units for each layer, rather than sampling only the maximal number of hidden units...

    2021

  4. [21]

    Baseline Configurations

    Number of Epochs 400 Condition Length 20% Tmax Prediction Length 80% Tmax 10 A. Baseline Configurations. a) LC-BNN.: LC-BNN is a function that maps a tuple containing a configuration and an epoch (configuration, epoch) to the loss value associated with that configuration at th...

    2023

  5. [1996]

    Graph attention networks,

    P. Veliˇckovi´c, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y . Bengio, “Graph attention networks,” arXiv preprint arXiv:1710.10903,

    arXiv

  6. [2014]

    Accelerating neural architecture search using performance prediction,

    B. Baker, O. Gupta, R. Raskar, and N. Naik, “Accelerating neural architecture search using performance prediction,” arXiv preprint arXiv:1705.10823 ,

    arXiv

  7. [2015]

    Probabilistic rollouts for learning curve extrapolation across hyperparam- eter settings,

    M. Gargiani, A. Klein, S. Falkner, and F. Hutter, “Probabilistic rollouts for learning curve extrapolation across hyperparam- eter settings,” arXiv preprint arXiv:1910.04522 ,

    1910 arXiv

  8. [2017]

    Tcnn: Temporal convolutional neural network for real-time speech enhancement in the time domain,

    A. Pandey and D. Wang, “Tcnn: Temporal convolutional neural network for real-time speech enhancement in the time domain,” in ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2019, pp. 6875–6879. X. Dong and Y . Yang, “Na...

    2019 arXiv

  9. [2018]

    Semi-supervised classifica- tion with graph convolutional networks,

    T. N. Kipf and M. Welling, “Semi-supervised classifica- tion with graph convolutional networks,” arXiv preprint arXiv:1609.02907,

    arXiv

  10. [2019]

    Efficient bayesian learning curve extrapolation using prior-data fitted networks,

    S. Adriaensen, H. Rakotoarison, S. M ¨uller, and F. Hutter, “Efficient bayesian learning curve extrapolation using prior-data fitted networks,” in Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 202...

    2023

  11. [2020]

    A generic graph-based neural architecture encoding scheme for predictor-based nas,

    X. Ning, Y . Zheng, T. Zhao, Y . Wang, and H. Yang, “A generic graph-based neural architecture encoding scheme for predictor-based nas,” in European Conference on Com- puter Vision. Springer, 2020, pp. 189–204. Y . Xu, Y . Wang, K. Han, H. Chen, Y . Tang, S. Jui, C. Xu, Q. Tia...

    2020 arXiv

  12. [2022]

    How powerful are graph neural networks?

    K. Xu, W. Hu, J. Leskovec, and S. Jegelka, “How powerful are graph neural networks?” arXiv preprint arXiv:1810.00826 ,

    arXiv

  13. [2023]

    Freeze-thaw bayesian optimization,

    [Online]. Available: http://papers.nips.cc/paper files/paper/2023/hash/ 3f1a5e8bfcc3005724d246abe454c1e5-Abstract-Conference. html K. Swersky, J. Snoek, and R. P. Adams, “Freeze-thaw bayesian optimization,” arXiv preprint arXiv:1406.3896 ,

    2023 arXiv

  14. [2024]

    A variational perspective on high-resolution odes,

    [Online]. Available: https://jmlr.org/papers/v25/23-1042.html H. Maskan, K. Zygalakis, and A. Yurtsever, “A variational perspective on high-resolution odes,” in Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 202...

    2023

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.