🤖 machine learning

Prediction of Runtime Parameters of Parallel Chemistry Applications via Active and Generative Learning

This paper presents a machine learning framework combining active and generative learning with gradient boosted regression trees to accurately predict runtime parameters for scalable parallel chemistry computations, achieving near-perfect accuracy and maintaining high performance even with significantly reduced training data.

Original authors: Tanzila Tabassum, Omer Subasi, Ajay Panyala, Epiya Ebiapia, Gerald Baumgartner, Erdal Mutlu, P Sadayappan, Karol Kowalski

Published 2026-06-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Tanzila Tabassum, Omer Subasi, Ajay Panyala, Epiya Ebiapia, Gerald Baumgartner, Erdal Mutlu, P Sadayappan, Karol Kowalski

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to bake the perfect cake, but you don't have a recipe. You know that the time it takes to bake depends on three things: how big the cake is (problem size), how many ovens you use (node count), and how you arrange the batter in the pans (tile size).

If you guess wrong, you might burn the cake or waste hours of oven time. In the world of supercomputers, "burning the cake" means wasting millions of dollars worth of electricity and computer time. This paper is about teaching a computer to become a master baker who can predict exactly how long a "cake" (a complex chemistry calculation called CCSD) will take to bake, so scientists don't have to guess.

Here is the story of how they did it, using simple analogies:

1. The Problem: The Expensive Guessing Game

Supercomputers are like massive, high-tech kitchens. Scientists use them to simulate how molecules interact. But these simulations are incredibly expensive to run.

The Dilemma: Before starting a simulation, a scientist has to choose the settings. If they pick the wrong settings, the computer might run for 10 hours when it could have finished in 2.
The Goal: The researchers wanted to build a "crystal ball" (a Machine Learning model) that could look at a problem and say, "If you use 50 ovens and this specific arrangement, it will take exactly 42 minutes."

2. The Crystal Ball: Testing Different "Seers"

The team tried many different types of "seers" (Machine Learning algorithms) to see which one was the best at predicting time. They tested things like:

Polynomial Regression: Like trying to draw a smooth curve through a few scattered dots.
Decision Trees: Like a flowchart of "If this, then that" questions.
Gradient Boosting: This is the winner. Imagine a team of detectives. The first detective makes a guess. The second detective looks at where the first one was wrong and tries to fix it. The third detective fixes the second one's mistakes, and so on. By the end, the team is incredibly accurate.

The Result: The "Gradient Boosting" team was the best. When they had a lot of historical data (like a full cookbook of past baking times), they were almost perfect, predicting the time with 99.9% accuracy.

3. The Challenge: What If You Have No Cookbook?

Here is the catch: Supercomputer time is so expensive that scientists often don't have enough past data to train a perfect model. They might only have a few recipes (data points) but need to bake a thousand different cakes.

To solve this, the researchers used two clever tricks:

Trick A: The "Smart Taster" (Active Learning)

Imagine you are a chef trying to learn a new cuisine, but you can only afford to taste 20 dishes out of 1,000.

Random Tasting: You just pick 20 dishes at random. You might miss the most important flavors.
Smart Tasting (Active Learning): You ask your computer, "Which 20 dishes will teach me the most?"
- Uncertainty Sampling: The computer says, "I'm really confused about these specific dishes. Let's taste them so I can learn."
- Committee Disagreement: Imagine a panel of chefs. If they all agree on a dish, you skip it. If they are arguing fiercely about a dish, you taste that one because it holds a secret they can't agree on.

The Result: Using this "Smart Taster" approach, the researchers could build a highly accurate model using only 20–25% of the data they normally would need. They saved a massive amount of money and time.

Trick B: The "Imagination Machine" (Generative Learning)

Imagine you have only 10 photos of a landscape, but you need to train a robot to recognize the whole terrain.

The Solution: You use an "Imagination Machine" (Generative AI) to create 20 new, fake photos that look exactly like the real ones. These aren't real photos, but they follow the same rules (the clouds are in the right place, the trees look real).
The researchers used two types of imaginations:
- Gaussian Copula: A statistical machine that understands how variables relate (e.g., "If the cake is bigger, it usually takes longer").
- CTGAN: A more complex neural network that can handle messy, mixed-up data.

The Result: These machines created "synthetic" data that helped the model learn faster. However, the paper notes that sometimes making up data can introduce a little bit of "noise" or confusion, so the "Smart Taster" (Active Learning) was often the more reliable method.

4. The Two Big Questions They Answered

The researchers tested their crystal ball on two specific questions that scientists ask every day:

The "Fastest Route" Question (Shortest-Time Question):
- Question: "I have a big problem. What settings will get me the result in the shortest time possible?"
- Answer: The model successfully identified the fastest settings, often suggesting using more computers (nodes) to speed things up, even if it costs more money.
The "Budget" Question (Budget Question):
- Question: "I only have $500 worth of computer time. What problems can I actually solve?"
- Answer: The model successfully found settings that fit the budget, often suggesting using fewer computers to stretch the money further, even if it takes a bit longer.

5. The Final Verdict

The paper concludes that by using these Machine Learning tricks, scientists don't have to waste time and money guessing how to run their supercomputer jobs.

If they have lots of data, a simple "Gradient Boosting" model works perfectly.
If they have very little data, the "Smart Taster" (Active Learning) can teach the computer with just a fraction of the usual experiments.

In short, they built a tool that helps scientists stop guessing and start knowing, saving the supercomputing world from burning its "cakes" and wasting its "ovens."

Technical Summary: Prediction of Runtime Parameters of Parallel Chemistry Applications via Active and Generative Learning

Problem Statement
Large-scale electronic-structure calculations, specifically Coupled-Cluster with Singles and Doubles (CCSD), impose significant computational demands on supercomputing systems. The execution time of these massively parallel applications depends on complex interactions between problem size (number of molecular orbitals), target hardware architecture, and runtime settings such as node count and tile size. Identifying optimal configurations through trial-and-error is impractical due to the high cost of wasted node-hours under limited resource allocations. While theoretical scaling laws and empirical heuristics exist, they often fail to predict actual runtimes or optimal configurations accurately due to communication overhead, load imbalance, and heterogeneous hardware effects. The paper addresses the need for accurate runtime prediction models to assist users in two primary decision-making scenarios: the Shortest-Time Question (STQ), which seeks the configuration minimizing execution time for a given problem size, and the Budget Question (BQ), which identifies configurations adhering to specific resource constraints (e.g., node-hours or time limits). A critical challenge is the scarcity of historical runtime data, as collecting sufficient measurements from expensive supercomputer runs is often infeasible.

Methodology
The authors propose a machine learning framework that combines supervised learning with active and generative learning strategies to address data scarcity.

Baseline Supervised Learning: The study evaluates a suite of regression models, including Polynomial Regression, Kernel Ridge Regression, Decision Trees, Random Forests, Gradient Boosted Trees (GB), Ada Boosting Trees, Gaussian Processes (GPs), Bayesian Ridge Regression, and Support Vector Regression. Hyperparameter tuning is performed using Grid Search, Random Search, and Bayesian Optimization. The models are trained on runtime data collected from CCSD executions on three Department of Energy (DOE) supercomputers: Aurora (ALCF), Frontier (OLCF), and Perlmutter (NERSC).
Active Learning: To mitigate the lack of large training datasets, the authors employ active learning to select the most informative configurations for test runs. Two query strategies are implemented:
- Uncertainty Sampling (US): Uses a Gaussian Process model to query data points where the model's prediction uncertainty (variance) is highest.
- Query-by-Committee (QC): Uses an ensemble of Gradient Boosting models to query points where the committee members show the greatest disagreement.
  The process iteratively adds these selected points to the training set to improve model accuracy with fewer labeled samples.
Generative Learning: To further augment sparse datasets, the authors utilize generative models to synthesize plausible data points that preserve the statistical properties of the original data. Two synthesizers are compared:
- Gaussian Copula: A statistical method that models variable dependencies by transforming data into Gaussian space.
- Conditional Tabular Generative Adversarial Networks (CTGAN): A deep learning approach designed for mixed-type tabular data, capable of handling discrete and continuous variables and imbalanced distributions.

Key Contributions

Development of High-Performance Predictive Models: The study implements and evaluates a comprehensive suite of ML models for predicting CCSD runtime parameters. It identifies Gradient Boosting as the most accurate and robust predictor across all three tested supercomputing platforms, achieving high $R^2$ scores and low Mean Absolute Percentage Error (MAPE) when sufficient data is available.
Integration of Active and Generative Learning: The paper demonstrates the efficacy of using active and generative learning to overcome data scarcity. It shows that accurate runtime prediction models can be trained using only 20–25% of the original dataset size by strategically selecting informative samples or augmenting data with synthetic points.
Comprehensive Cross-Platform Evaluation: The framework is rigorously evaluated using real-world performance data from three premier DOE supercomputers (Aurora, Frontier, Perlmutter), addressing both the STQ and BQ objectives.

Results

Baseline Performance: On the full datasets, the Gradient Boosting model achieved exceptional accuracy. For the STQ on Aurora, it reached a MAPE of 0.023 and an $R^2$ of 0.999. For the BQ, it achieved a MAPE of 0.12 and an $R^2$ of 0.979. Similar high performance was observed on Frontier and Perlmutter.
Active Learning Efficiency: Using active learning, the models achieved a MAPE of approximately 0.2 with only 20–25% of the original dataset. Specifically, on Aurora, a MAPE of 0.2 was reached with 450 data points (25% of the dataset), improving to 0.1 with roughly 550 points. The Uncertainty Sampling strategy generally outperformed Query-by-Committee on Aurora, while QC performed better on Frontier and Perlmutter for certain objectives.
Generative Learning Impact: Generative learning showed modest improvements in performance, particularly for MAPE, when synthetic data was added. However, the authors note that synthetic data can introduce instability in learning, especially with smaller base datasets. The Gaussian Copula synthesizer was significantly faster to fit than CTGAN (approx. 160x), though sampling times were comparable.
Statistical Analysis: The study analyzed the mean, variance, and standard deviation of runtimes in selected batches. Active learning strategies (US and QC) were found to initially select configurations with higher runtimes and greater variance (where model uncertainty or disagreement is highest) before converging toward more homogeneous, lower-runtime batches as the model learned.

Significance
The paper claims that its approach provides a practical framework for reducing the burden of parameter selection in large-scale quantum chemistry simulations. By enabling accurate runtime predictions with significantly fewer expensive supercomputer runs, the methodology facilitates more efficient resource usage, faster configuration tuning, and improved user decision-making regarding computational budgets. The work highlights that while traditional supervised learning is highly effective with abundant data, active and generative learning strategies are viable alternatives for scenarios where data collection is constrained by cost and time.