Pith. sign in

REVIEW 4 major objections 5 minor 16 references

Open source Differentiable ODE Solving Infrastructure

T0 review · 4 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

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

Pith's one-line read DeepChem now provides GPU-accelerated, fully differentiable ODE solvers that the authors report as accurate to 10^-4 to 10^-6 and scalable to 100-compartment models.

desk verdict Useful DeepChem ODE integration with working demos, but the abstract's MSE accuracy claim is absent from the body and no code link is provided; needs a careful revision before it earns trust. read the letter →

arxiv 2411.19882 v1 pith:DWJXVX3A submitted 2024-11-29 cs.LG

Rakshit Kr. Singh , Aaron Rock Menezes , Rida Irfan , Bharath Ramsundar This is my paper · ORCID
classification cs.LG
keywords differentiableprogrammingODEsolversDeepChemRunge-KuttamethodsneuralODEspharmacokineticsGPUaccelerationparameterestimation
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 adds GPU-accelerated, fully differentiable ordinary differential equation (ODE) solvers to DeepChem, an open-source machine-learning library for drug discovery and materials science. It claims the solvers are accurate, reporting mean squared errors between $10^{-4}$ and $10^{-6}$, and scalable, solving pharmacokinetic compartment models with up to 100 compartments. The authors demonstrate the infrastructure across four tasks: Lotka-Volterra population dynamics, pharmacokinetic parameter estimation, training neural ODEs, and solving reaction-diffusion PDEs via the method of lines. The goal is to make differentiable simulation a first-class tool inside a Python ML ecosystem, so researchers can embed physics-based models directly into gradient-based pipelines.

What carries the argument

The central mechanism is the differentiable fixed-step Runge-Kutta integrator written in PyTorch, exposed through DeepChem's optimizer and solver API. Because each update step is a differentiable operation, gradients flow backward through the whole integration, allowing the same solver to be used as a forward simulator and as a layer in a neural ODE or parameter-estimation loop. The paper pairs RK4/RK38 stepping with gradient-based and root-finding optimizers (Adam, gradient descent, Broyden) that DeepChem exposes for parameter learning.

What would settle it

Solve the 100-compartment model again at halves of the reported step size (h=0.01, 0.005, 0.0025) and compare successive trajectories, or compare against an adaptive high-tolerance solver (e.g., SciPy with tight tolerances); if the trajectory does not converge at the rate expected of a fourth-order method, the claimed $10^{-4}$ to $10^{-6}$ accuracy is not established.

Watch

Extended reading notes

Core claim

The paper's central claim is that DeepChem can now serve as a fully differentiable (autodiff-compatible) ODE-solving environment, matching the capabilities of standalone differentiable solvers while being native to the library's Python and PyTorch-based workflows. The authors implement fixed-step Runge-Kutta integrators (RK4 and RK38) in pure Python/PyTorch, running on GPU, and combine them with optimizers such as Adam, gradient descent, and Broyden root-finding to support parameter estimation. Experiments show close agreement with SciPy's adaptive solvers on predator-prey and multi-compartment pharmacokinetic models, and the implementation scales to a 100-compartment model. The paper also uses the solver as a differentiable core for a neural ODE and for simulating reaction-diffusion patterns, demonstrating composability.

Load-bearing premise

The results assume that a fixed-step Runge-Kutta 3/8 integrator with step size 0.01 delivers accurate trajectories for the tested models, especially the 100-compartment pharmacokinetic system, without adaptive error control or a convergence check.

Editorial extensions

If this is right

  • Researchers in systems biology and drug discovery can estimate pharmacokinetic model parameters from data directly inside DeepChem using gradient-based methods.
  • Differentiable ODE solvers enable neural ODEs and physics-informed models to be trained through arbitrary integration horizons within standard PyTorch pipelines.
  • The method-of-lines treatment of reaction-diffusion PDEs suggests the same infrastructure can handle a wider class of PDEs by spatial discretization.
  • Because the solvers are open source and Python-native, they lower the barrier to GPU-accelerated simulation for users already working in DeepChem or Torch.
  • The scaling demonstration to 100 compartments gives a concrete data point for multi-compartment pharmacokinetic simulations, although timing remains slower than SciPy's adaptive CPU solvers.

Reading between the lines

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

  • Our inference: the reported errors are for fixed configurations (step size 0.01, time windows as listed); the absence of step-size refinement or comparison against high-accuracy references leaves the error claims tied to those settings.
  • Our inference: for stiff biological systems, the fixed-step explicit Runge-Kutta approach may require very small steps or an implicit/adaptive method; a convergence study would reveal whether the 100-compartment model is stiff.
  • Our inference: the differentiable solver should make it easy to turn the 100-compartment model into an end-to-end learnable module, e.g., calibrating absorption and elimination rates from sparse clinical measurements.
  • Our inference: the same pattern-formation results for reaction-diffusion suggest the solver can be used for inverse problems in developmental biology, where one fits diffusion and reaction coefficients to observed spatial patterns.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper reports an integration of GPU-accelerated, fully differentiable ODE solvers into the DeepChem open-source framework, building on the ξ-torch library. The authors demonstrate the solvers on Lotka–Volterra dynamics, pharmacokinetic compartment models (3, 10, and 100 compartments), neural ODE training on a damped harmonic oscillator, and a reaction–diffusion PDE solved via method of lines. They report wall-clock times compared to torchdiffeq and SciPy, L1 trajectory differences against SciPy, and parameter estimation results for the Lotka–Volterra model. The central claim, stated in the abstract, is that the solvers achieved high accuracy with mean squared errors between 10^-4 and 10^-6 and scaled to 100 compartments.

Significance. If the accuracy and scalability claims are supported, this would provide a useful, openly accessible differentiable ODE-solving tool within a widely used cheminformatics and ML ecosystem, enabling applications such as pharmacokinetic simulation, parameter estimation, and neural ODE training without leaving DeepChem. The paper also demonstrates composability of the solvers with optimizers and neural networks. The open-source nature of the infrastructure and the inclusion of tutorials are concrete strengths. However, the paper's central quantitative claim (MSE 10^-4 to 10^-6) is not reported in the body, and the fixed-step integration experiments lack convergence or stiffness verification, so the significance rests on claims that are currently unverified.

major comments (4)
  1. [Abstract and Experiments and Results] The abstract states that the solvers 'achieved high accuracy with mean squared errors ranging from 10^-4 to 10^-6', but no mean squared error is reported anywhere in the body. Tables 2 and 4 report only L1 distances (0.0197, 0.0275, 0.0156), and Table 3 reports only runtimes. This is a load-bearing quantitative claim that the reader cannot verify or reproduce from the presented data; either the MSE values must be reported (with the corresponding trajectories and error definitions) or the abstract must be revised to match the evidence actually provided.
  2. [Experiments and Results, Pharmacokinetic Compartment Model] The fixed-step RK38 runs use h=0.01 over t in [0,100] without any convergence study or comparison against a high-accuracy reference trajectory. The paper compares against SciPy's adaptive RK5(4) solver with default tolerances, which is not a ground truth and may itself carry nontrivial error. Given that the introduction specifically discusses stiffness in biological models, the absence of a stiffness check or a convergence test for the 3-, 10-, and 100-compartment systems leaves the claimed accuracy and the 'scalability' statement (which is runtime-only) without numerical support.
  3. [Methodology and Experiments and Results] The paper advertises GPU-accelerated solvers, but the experiments provide no CPU-versus-GPU comparison, no GPU utilization metrics, and no evidence that the GPU execution delivers any benefit. The wall-clock comparisons in Tables 1 and 3 are between a Python/fixed-step implementation (DeepChem, torchdiffeq) and a compiled/adaptive implementation (SciPy), which the authors acknowledge are not directly comparable. Without a CPU baseline for the DeepChem solvers, the GPU acceleration claim is unsubstantiated.
  4. [Table 5, Parameter Estimation] The parameter estimation results in Table 5 are presented without any error metric or convergence details. The estimates from the DeepChem solver with the SciPy minimizer deviate substantially from ground truth (e.g., α=0.8646 vs 1.1), while the DeepChem solver with the DeepChem Adam minimizer is much closer; no explanation or measure of uncertainty is given. This makes it difficult to evaluate the paper's claim of 'high accuracy in parameter estimation' in the Conclusion.
minor comments (5)
  1. [Throughout] There are several typographical errors and formatting issues, including 'CSystemIdentification' in the methodology section, 'DeepCehm' in Table 1, and inconsistent spacing in author names in the references (e.g., 'Chen, R. T. Q.; Rubanova, Y .').
  2. [Experiments and Results, Training Neural ODEs] The experimental setup for the neural ODE says the model is trained on data from t=0 to 30, and Figure 5 mentions predicting the next 30 seconds, but it is not stated whether the reported L1 error (0.0156) is on the training interval or the extrapolation interval; please clarify.
  3. [Conclusion] The conclusion states 'DeepChem to be slightly faster than torchdiffeq' based on Table 1, but the times (52.2793 vs 54.4566 s) are within a few percent and no variance or repeated-run statistics are reported; a stronger statement would acknowledge the lack of statistical significance.
  4. [Experimental Setup, Predator-Prey Model] The setup says 'we solve 10 models' with initial values and rate constants varying in ranges, but it is not specified whether the L1 distances in Table 2 are averaged over those 10 models or computed for a single representative run; please state this explicitly.
  5. [References] The reference for the differentiable physics position piece is cited as 'Ramsundar, Krishnamurthy, and Viswanathan 2021' in the text but appears as 'Ramsundar, B.; Krishnamurthy, D.; and Viswanathan, V . 2021' in the list; ensure the citation style is consistent.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the ODE solver validation is benchmarked against independent implementations and the parameter-estimation and neural-ODE tests use independently generated targets.

full rationale

I walked the paper's derivation and validation chain and found no step in which a claimed prediction or first-principles result reduces by construction to its inputs. The central validation compares DeepChem's RK38 trajectories against SciPy's adaptive RK5(4) solver and torchdiffeq (Tables 1-3); these are external baselines, not quantities fitted within the paper. The parameter-estimation experiments use known ground-truth Lotka-Volterra parameters (Table 5) and measure how well the solver-plus-minimizer recovers them, which is a genuine inverse-problem check rather than a renamed fit. The neural ODE experiment trains on the first 30 seconds of a damped harmonic oscillator and then extrapolates the next 30 seconds; the extrapolation interval was not used in training, so it is a real out-of-sample prediction. The self-citations (Ramsundar et al. 2019 for DeepChem; Ramsundar et al. 2021 for differentiable physics) provide context and motivation but are not load-bearing for the accuracy or scalability claims. The abstract asserts mean squared errors of 10^-4 to 10^-6, but the body reports only L1 distances and wall-clock times; this is a reporting/validation gap, not circularity, because the missing MSE values are not defined in terms of the output being predicted. Similarly, the fixed-step RK38 experiments lack a convergence study or stiffness check, but that is a correctness risk, not a circular-reasoning defect. No equation in the paper is defined in terms of the result it is used to derive, and no fitted parameter is relabeled as a prediction. Therefore the appropriate finding is no significant circularity.

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

The central claim rests on standard numerical analysis, on PyTorch autograd, and on the correctness of the ξ-torch code that was adapted. No new free parameters or invented entities are introduced; the trained neural ODE weights and estimated Lotka-Volterra parameters are experimental objects, not assumptions of the derivation.

assumptions (3)
  • standard math Runge-Kutta methods (RK4, RK38) converge to the true solution of the tested non-stiff ODE systems at the chosen fixed step sizes.
    The accuracy demos assume fixed-step RK solutions are accurate references; the paper does not verify convergence with a step-size study.
  • domain assumption PyTorch autograd computes correct gradients through the implemented solver steps, so optimization of Neural ODE and parameter estimation is valid.
    The paper relies on automatic differentiation through the fixed-step RK loop without gradient checks (e.g., finite-difference or adjoint verification).
  • ad hoc to paper The ξ-torch implementation adapted into DeepChem is itself correct and differentiable.
    The implementation builds directly on (Kasim and Vinko 2020) and inherits its correctness, which the paper does not independently verify.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Open source Differentiable ODE Solving Infrastructure." pith.science (2026). https://pith.science/paper/DWJXVX3A

@misc{pith2026241119882,
  author       = {Pith},
  title        = {Pith review of: Open source Differentiable ODE Solving Infrastructure},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DWJXVX3A}},
  note         = {Machine review of arXiv:2411.19882}
}
abstract

Ordinary Differential Equations (ODEs) are widely used in physics, chemistry, and biology to model dynamic systems, including reaction kinetics, population dynamics, and biological processes. In this work, we integrate GPU-accelerated ODE solvers into the open-source DeepChem framework, making these tools easily accessible. These solvers support multiple numerical methods and are fully differentiable, enabling easy integration into more complex differentiable programs. We demonstrate the capabilities of our implementation through experiments on Lotka-Volterra predator-prey dynamics, pharmacokinetic compartment models, neural ODEs, and solving PDEs using reaction-diffusion equations. Our solvers achieved high accuracy with mean squared errors ranging from $10^{-4}$ to $10^{-6}$ and showed scalability in solving large systems with up to 100 compartments.

Figures

Figures reproduced from arXiv: 2411.19882 by the authors.

Figure 1
Figure 1. DeepChem ODE Solving workflow Pharmacokinetics Simulation using DeepChem Pharmacokinetics models use mathematical equations to de￾scribe how a drug is absorbed, distributed, metabolized, and excreted in the body over time. These models help understand the drug’s concentration in different compart￾ments of the body and ensure therapeutic levels are achieved without causing toxicity. In drug discovery, pharmacokinet￾i… view at source ↗
Figure 2
Figure 2. DeepChem parameter estimation workflow equations (ODEs): the Predator-Prey model and the Com￾partment model. These models are chosen because they ex￾emplify different applications of ODEs in biology, with one focusing on population dynamics and the other on substance distribution across compartments. We solve these ODEs us￾ing our implementations of Runge-Kutta methods and ana￾lyze their accuracy and efficiency. Spe… view at source ↗
Figure 3
Figure 3. Predator-prey equation solutions obtained using [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Schematic representation of a three-compartment [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: Harmonic Oscillator Dynamics using Neural [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Reaction-Diffusion Dynamics: Simulating Pat [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Schematic representation of a model with 10 com [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Compartment model showing interaction between [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

16 extracted references · 15 canonical work pages

  1. [1]

    ,∂f ∂θn T (14)

    Compute the Gradient: ∇f (θk) = ∂f ∂θ1 , ∂f ∂θ2 , . . . ,∂f ∂θn T (14)

    work page

  2. [2]

    Update the Parameters: θk+1 = θk − α∇f (θk) (15)

    work page

  3. [3]

    • Otherwise, set k = k + 1and repeat

    Convergence Check: • If ∥∇f (θk+1)∥ is below a predefined threshold, stop. • Otherwise, set k = k + 1and repeat. Broyden’s First Method Broyden’s First Method itera- tively updates an approximation of the Jacobian matrix. Mathematical Formulation Given the current iterate xk, the Jacobian approximation Bk, and the function evaluationF(xk), the method proc...

    work page

  4. [4]

    Broyden’s Second Method Broyden’s Second Method it- eratively updates an approximation of the inverse Jacobian matrix

    Update the Jacobian Approximation The Jacobian is updated using a rank-one update for- mula: Bk+1 = Bk + (yk − Bksk)s⊤ k s⊤ k sk (19) Here, s⊤ k denotes the transpose of sk. Broyden’s Second Method Broyden’s Second Method it- eratively updates an approximation of the inverse Jacobian matrix. Algorithm Steps Given: • An initial guess x0. • An initial inver...

    work page

  5. [5]

    Update the Inverse Jacobian Approximation: The inverse Jacobian is updated using a rank-one update formula: Bk+1 = Bk + (sk − Bkyk)s⊤ k Bk s⊤ k Bkyk (24) Here, s⊤ k denotes the transpose of sk

    work page

  6. [6]

    Otherwise, setk = k+1 and repeat the iteration

    Convergence Check: If ∥F(xk+1)∥ is below a predefined tolerance level, ter- minate the algorithm. Otherwise, setk = k+1 and repeat the iteration. Pharmacokinetic Compartment Models Pharmacoki- netic compartment models are mathematical models used to describe the way drugs are absorbed, distributed, metabo- lized, and eliminated by the body. These models s...

    work page

  7. [7]

    Compute the Newton Step Solve the linear system to find the step sk.: Bksk = −F(xk) (16)

    work page

  8. [8]

    Update the Solution xk+1 = xk + sk (17)

    work page

Show all 16 references
  1. [9]

    Compute the Change in Function Values yk = F(xk+1) − F(xk) (18)

  2. [11]

    Compute the Newton Step: Solve the linear system: BkF(xk) =−sk (20) to find the step sk

  3. [12]

    Update the Solution: xk+1 = xk + sk (21)

  4. [13]

    Evaluate the Function at the New Point: F(xk+1) (22)

  5. [14]

    Compute the Change in Function Values: yk = F(xk+1) − F(xk) (23)

  6. [2008]

    Journal of Phar- maceutical Sciences, 97(2): 654–690

    Pharmacokinetics in drug discovery. Journal of Phar- maceutical Sciences, 97(2): 654–690. Runge, C. 1895. ¨Uber die numerische Aufl¨osung von Differ- entialgleichungen. Mathematische Annalen, 46: 167–178. St¨adter, P.; Sch ¨alte, Y .; Schmiester, L.; Hasenauer, J.; and Stapor,...

    2021

  7. [2018]

    In NIPS’18: Proceedings of the 32nd International Conference on Neural Information Processing Systems , 10201–10212

    Backpropagation with Callbacks: Foundations for Efficient and Expressive Differentiable Programming. In NIPS’18: Proceedings of the 32nd International Conference on Neural Information Processing Systems , 10201–10212. Curran Associates. Willmott, C. J.; and Matsuura, K. 2005. ...

    2005

  8. [2021]

    arXiv preprint arXiv:2109.07573

    Differentiable physics: A position piece. arXiv preprint arXiv:2109.07573. Ruiz-Garc´ıa, A.; Bermejo, M.; Moss, A.; and Casabo, V . G

    arXiv

Pith tools

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