From paper summary to your first question

This paper examines whether machine-learning (ML) surrogates accelerate AC power-flow computation relative to well-parallelized CPU solvers and modern batched GPU physics solvers, rather than a single CPU baseline. Power-flow computation determines bus voltages consistent with specified generation, demand, and network parameters, supporting grid operations and training-data generation. The authors argue that baseline selection can reverse conclusions about ML’s usefulness: throughput across the seven CPU implementations tested varies by approximately 2.5–3 orders of magnitude. The benchmark covers 15 grids ranging from 14 to 70,000 buses and compares seven CPU-based Newton–Raphson solvers, two GPU-based physics solvers, and three published graph-neural-network (GNN) surrogates: PowerFlowNet, Graph Neural Solver, and CANOS-PF. The authors also introduce gpusim2grid, which uses CUDA and NVIDIA’s cuDSS sparse solver to execute batched Newton–Raphson iterations entirely on the GPU. By exploiting shared sparsity patterns across scenarios, it avoids CPU–GPU transfers during iterative computation. To verify that the implementations solve the same equations, the authors independently construct a common Kirchhoff’s current law mismatch evaluator and configure the solvers to align network representations and modeling assumptions. Accuracy validation uses 9,000 identical sampled scenarios per grid, with a target tolerance of 10⁻⁸. Five iterations of gpusim2grid achieve a mean mismatch of 8.91 × 10⁻¹⁴ and a worst-case mismatch of 2.31 × 10⁻¹⁰, both comfortably below the tolerance. Four iterations are insufficient, yielding a worst-case mismatch of 1.16 × 10⁻⁴. The pandapower reference achieves a mean mismatch of 5.61 × 10⁻¹¹. Solver robustness nevertheless varies: PowerModels reports 78.57% convergence across its tested grids, while Power Grid Model succeeds only on smaller grids. Throughput experiments vary generation and demand while keeping network topology fixed and optimizing CPU worker counts and GPU batch sizes. Measurements include input updates and CPU–GPU data transfers but exclude initialization, compilation, and disk loading. The CPU experiments comprise approximately 630 million power-flow solves and 4,700 CPU-hours. On the primary benchmark machine, lightsim2grid is the fastest CPU implementation, Graph Neural Solver is the fastest tested ML surrogate, and gpusim2grid is the fastest GPU physics solver. CPU parallelization provides an average speedup of approximately 16-fold over single-core execution. Although the fastest surrogate outperforms a single core of the fastest CPU baseline, it does not outperform the fully parallelized CPU solver. Overall, gpusim2grid and parallelized lightsim2grid match or exceed the tested surrogates’ throughput, with comparable throughput on the largest grids. A separate accuracy comparison uses the IEEE-118 PF-Delta datasets and published GENCO Base results. Under normal operating conditions, mean power-balance loss is 0.0027 for GENCO, compared with 1.1 × 10⁻⁶ for pandapower and 4.9 × 10⁻¹⁴ for gpusim2grid. Physics solvers also substantially outperform GENCO under single and double contingencies. Near-infeasible cases are more challenging, and pandapower’s average is strongly affected by three nonconverging samples. The authors conclude that the tested GNN surrogates have not yet demonstrated a compelling speed–accuracy advantage for standard power-flow computation. This conclusion does not rule out ML benefits in optimization, state estimation, or control. Study limitations include synthetic scenarios, limited hardware coverage, best-observed timings without repeated-run statistics, and the application of unchanged surrogate architectures to grids beyond their training sizes. The GPU implementation is CUDA-only, and occasional cuDSS-related numerical failures have been reported. The findings therefore support broader, carefully matched benchmarking rather than a universal ranking of solvers or a rejection of learned methods.

1. Scientists tested different computer tools on 15 electric power networks, and choosing a slow tool for comparison could make another tool look much faster.
2. A new tool called gpusim2grid does its math on a special computer chip and needed five rounds to get answers close enough to correct.
3. Letting a regular computer chip do many jobs at once made its tools about 16 times faster on average.
4. Tools that follow electricity rules matched or beat the tested learning tools in speed and gave better-balanced electricity answers.
5. These tests had limits, so they do not prove which tool is always best or mean that learning tools cannot help with other jobs.

Definitions

• electric power network: connected wires and equipment that carry electricity.
• comparison: looking at things together to see how they differ.
• gpusim2grid: the name of a computer tool that works out how electricity moves through a network.
• computer chip: a tiny part inside a computer that does work.
• round: one more try at improving an answer.
• learning tool: a computer program that learns patterns from examples.
• balanced: having the electricity going in match the electricity used or lost.
• limits: things a test did not check or could not do.

• Baseline choice can reverse conclusions about ML performance: throughput among seven tested CPU solvers varies by roughly 2.5–3 orders of magnitude.
• The benchmark compares seven CPU solvers, two GPU physics solvers, and three GNN surrogates across 15 grids ranging from 14 to 70,000 buses.
• The new gpusim2grid solver performs batched Newton–Raphson iterations entirely on the GPU, exploiting shared sparsity and avoiding CPU–GPU transfers during iteration.
• Accuracy checks use a common equation-mismatch evaluator and 9,000 identical scenarios per grid. Five gpusim2grid iterations meet the 10⁻⁸ tolerance; four do not.
• CPU parallelization delivers an average speedup of about 16-fold. The fastest tested surrogate beats the fastest CPU solver on a single core, but not when that solver is fully parallelized.
• Overall, gpusim2grid and parallelized lightsim2grid match or exceed the tested surrogates’ throughput, including comparable throughput on the largest grids.
• Physics solvers achieve substantially better power-balance accuracy than GENCO under normal conditions and contingencies, although near-infeasible cases remain challenging.
• Timing measurements include input updates and CPU–GPU transfers but exclude initialization, compilation, and disk loading; experiments keep network topology fixed.
• The tested GNN surrogates have not demonstrated a compelling speed–accuracy advantage for standard power-flow computation; this does not rule out ML benefits in optimization, state estimation, or control.
• Limitations include synthetic scenarios, limited hardware, no repeated-run timing statistics, surrogate testing beyond training sizes, and CUDA-only implementation with occasional numerical failures. The findings support carefully matched benchmarking, not a universal solver ranking or rejection of ML.

Can Machine Learning Really Speed Up Power-Flow Computation?

Machine learning promises faster answers to many engineering problems. But speed depends on what you compare it with. A model that beats a single CPU core may look less impressive against a carefully parallelized solver or a physics-based algorithm running on a GPU.

That is the central question in “Benchmarking CPU, GPU, and ML Power-Flow Solvers from 14 to 70,000 Buses,” by Benjamin Donnot, Sami Tazi, Eva Boguslawski, and Nourredine Henka. Their study finds that the tested machine-learning surrogates do not establish a compelling speed–accuracy advantage over well-optimized conventional solvers. More broadly, it shows why choosing the right baseline can change a research conclusion.

Why Power Flow Matters

Power-flow computation determines the bus voltages consistent with a grid’s generation, electricity demand, and network parameters. These calculations support grid operations and generate training data for machine-learning systems. When many scenarios must be evaluated, throughput—the number of cases solved in a given time—becomes important.

Traditional solvers calculate solutions from the network’s physical equations, often using Newton–Raphson iterations. Learned surrogates instead approximate the relationship between inputs and solutions. Their appeal is straightforward: after training, prediction could be faster than repeatedly solving those equations. The challenge is delivering that speed without sacrificing accuracy.

A Benchmark That Looks Beyond One CPU Core

The researchers compare 15 grids ranging from 14 to 70,000 buses. Their benchmark includes seven CPU-based Newton–Raphson implementations, two GPU-based physics solvers, and three published graph-neural-network surrogates: PowerFlowNet, Graph Neural Solver, and CANOS-PF.

The choice of CPU implementation alone makes an enormous difference. Throughput across the seven implementations varies by approximately 2.5 to 3 orders of magnitude. Comparing a learned model with a slow baseline could therefore suggest an advantage that disappears against stronger software.

The experiments vary generation and demand while keeping network topology fixed. CPU worker counts and GPU batch sizes are optimized. Measurements include input updates and CPU–GPU transfers, but exclude initialization, compilation, and disk loading. The CPU experiments involve approximately 630 million power-flow solves and 4,700 CPU-hours.

Bringing Newton–Raphson Fully onto the GPU

The authors introduce gpusim2grid, a physics-based solver using CUDA and NVIDIA’s cuDSS sparse solver. It executes batched Newton–Raphson iterations entirely on the GPU.

Its design exploits shared sparsity patterns across scenarios: with topology fixed, the underlying network calculations retain a common structure. Keeping iterative computation on the GPU avoids repeated CPU–GPU transfers during those iterations. The approach demonstrates that modern hardware can accelerate conventional physics calculations, not just learned predictions.

Checking That Everyone Solves the Same Problem

Timing results mean little if implementations use different network assumptions or accept different errors. To address this, the researchers align modeling choices and independently construct a common Kirchhoff’s current law mismatch evaluator.

Accuracy validation uses 9,000 identical sampled scenarios per grid and a target tolerance of 10⁻⁸. Five gpusim2grid iterations achieve a mean mismatch of 8.91 × 10⁻¹⁴ and a worst-case mismatch of 2.31 × 10⁻¹⁰, both below the tolerance. Four iterations are insufficient, producing a worst-case mismatch of 1.16 × 10⁻⁴. The pandapower reference achieves a mean mismatch of 5.61 × 10⁻¹¹.

Robustness also varies across implementations. PowerModels reports 78.57% convergence across its tested grids, while Power Grid Model succeeds only on smaller grids. Speed is therefore only one part of solver performance.

What the Speed and Accuracy Results Show

On the primary benchmark machine, lightsim2grid is the fastest CPU implementation, Graph Neural Solver is the fastest tested surrogate, and gpusim2grid is the fastest GPU physics solver. CPU parallelization provides an average speedup of approximately 16-fold over single-core execution.

The fastest surrogate beats a single core of the fastest CPU baseline, but not the fully parallelized CPU solver. Overall, gpusim2grid and parallelized lightsim2grid match or exceed the tested surrogates’ throughput, with comparable throughput on the largest grids.

A separate accuracy comparison uses IEEE-118 PF-Delta datasets and published GENCO Base results. Under normal operating conditions, mean power-balance loss is 0.0027 for GENCO, compared with 1.1 × 10⁻⁶ for pandapower and 4.9 × 10⁻¹⁴ for gpusim2grid. Physics solvers also substantially outperform GENCO under single and double contingencies. Near-infeasible cases are harder, and three nonconverging samples strongly affect pandapower’s average.

A Call for Better Comparisons, Not an End to ML

The findings have boundaries. The study uses synthetic scenarios and limited hardware, reports best-observed timings without repeated-run statistics, and applies unchanged surrogate architectures to grids beyond their training sizes. The GPU implementation is CUDA-only, and occasional cuDSS-related numerical failures have been reported.

The conclusion is therefore specific: these tested GNN surrogates have not yet demonstrated a compelling advantage for standard power-flow computation. That does not rule out machine-learning benefits in optimization, state estimation, or control. The lasting lesson is methodological: credible acceleration claims require strong baselines, matched accuracy, and careful accounting of the work being timed.

Learned surrogates for power-flow (PF) computation are usually motivated by speed, compared against a single CPU-based baseline. We show this comparison is fragile: across 7 open-source CPU-based solvers evaluated on identical inputs, throughput varies by roughly 2.5-3 orders of magnitude, so the choice of baseline alone can flip the conclusion. We build a benchmark spanning 9 physics-based solvers: 7 CPU-based and 2 GPU-based, including a new batched GPU solver, gumsim2grid - and 3 published ML surrogates, evaluated under a shared, independently implemented KCL-mismatch check across 15 grids from 14 to 70,000 buses. On the PF task itself, a sufficiently parallelized CPU solver or gpusim2grid matches or exceeds the throughput of the ML surrogates we test while remaining orders of magnitude more accurate; we find no evidence that these GNN-style surrogates are yet competitive for PF specifically, though prior work reports genuine gains on related but more combinatorial tasks such as optimal power flow or power grid control. Beyond this finding, we hope the benchmark suite, code and reference evaluator released at https://github.com/Grid2op/gpusim2grid helps close a broader reproducibility gap in this space, where batched GPU-based PF solvers are rarely open-sourced or evaluated against a common set of baselines.