🤖 machine learning

LASER: Language Model Regression for Semi-Structured Workflow Resource and Runtime Estimation

LASER is a novel framework that fine-tunes large language models on serialized semi-structured workflow configurations to accurately predict resource consumption and runtime, outperforming traditional machine learning baselines and human experts by leveraging scientific notation encoding, constrained decoding, and full-attention mechanisms.

Original authors: Yuxuan Yin, Shengke Zhou, Yunjie Zhang, Ajay Mohindra, Boxun Xu, Peng Li

Published 2026-05-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuxuan Yin, Shengke Zhou, Yunjie Zhang, Ajay Mohindra, Boxun Xu, Peng Li

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 the manager of a massive, busy kitchen (a cloud computing system). Every day, hundreds of chefs (jobs) submit complex recipes (workflow configurations) to be cooked. Some recipes are simple, like boiling water; others are intricate, like a 10-course banquet that requires specific ovens, exact amounts of ingredients, and precise timing.

To run this kitchen efficiently, you need to know two things before you start cooking:

How long will this take? (Runtime)
How much fuel and space will it need? (Resources like CPU, memory, and disk)

If you guess wrong, you either waste money by ordering too much fuel (over-provisioning) or you burn the kitchen down because you didn't have enough power (under-provisioning).

The Old Way: The "Checklist" Problem

Traditionally, managers tried to predict this by turning every recipe into a long, boring checklist of numbers. They had to manually translate things like "use the aarch64 compiler" or "set Python version to 3.11" into specific numbers on a spreadsheet.

The problem? This checklist is brittle.

If a new tool appears in the kitchen, the checklist breaks because no one wrote a number for it.
It loses the story of the recipe. It sees "Python 3.11" as just a number, missing the fact that it's a specific version that behaves differently than 3.9.
It's like trying to predict how long a movie will take by only counting the number of pages, ignoring the plot, the actors, or the special effects.

The New Way: LASER (The "Smart Sous-Chef")

The paper introduces LASER, a system that uses a Large Language Model (LLM)—basically a super-smart AI that has read millions of recipes, code, and manuals—to act as a "Sous-Chef."

Instead of forcing recipes into a checklist, LASER reads the raw text of the job configuration. It understands the language of the recipe naturally.

It sees the command python script.py and understands the context.
It sees the dependencies and the hierarchy without needing a human to manually translate them into numbers first.

How LASER Solves Three Tricky Problems

1. The "Too Big or Too Small" Problem (Scientific Notation)
Resources vary wildly. A job might need 500 Megabytes of memory, while another needs 50 Terabytes. That's a huge gap.

The Analogy: Imagine trying to measure both a grain of sand and a mountain with the same ruler. It's messy.
The LASER Fix: LASER uses scientific notation (like $5.0 \times 10^2$ ). It teaches the AI to speak in "powers of ten." This allows the AI to handle tiny numbers and massive numbers equally well without getting confused or needing complex math adjustments.

2. The "Hallucination" Problem (Constrained Decoding)
When you ask a smart AI to give you numbers, it sometimes gets creative and makes things up (hallucinating). It might invent a fake file name or write a number that doesn't make sense.

The Analogy: Imagine asking a waiter for the bill, and they start inventing new menu items you didn't order.
The LASER Fix: LASER uses constrained decoding. It's like giving the waiter a pre-printed form with the exact boxes for "Time," "CPU," and "Memory." The AI is only allowed to fill in the numbers inside those boxes. It can't invent new boxes or write gibberish.
Bonus: Because the AI doesn't have to "think" about the structure of the sentence (since the structure is fixed), it answers 30% faster.

3. The "Long Story" Problem (Full Attention)
Some recipes are very long. A detail mentioned at the very beginning of the recipe might be crucial for a step at the very end.

The Analogy: Imagine reading a long novel but only remembering the last few pages. You might miss the plot twist that happened on page 1.
The LASER Fix: Most modern AI models only look at a "window" of text at a time (like reading a few pages at a time). LASER forces the model to use full attention, meaning it can look at the entire recipe from start to finish simultaneously. This helps it connect the dots between distant parts of the job configuration.

The Results

The authors tested LASER on two types of "kitchens":

Chip Design: A highly complex, industrial kitchen where a tiny change in a script can make a job take 10 times longer.
GitHub Actions: A public dataset of over 580,000 software jobs from 27,000 different repositories.

The Outcome:

LASER was more accurate than human experts.
It was better than traditional "checklist" (tabular) machine learning models.
It got even better as it was fed more data and used larger models (a "scaling law").
It could predict the needs of jobs it had never seen before, showing it learned the logic of the work, not just memorized the answers.

In short, LASER replaces the brittle, manual process of translating recipes into numbers with a smart, language-savvy AI that reads the recipe, understands the context, and gives a precise, reliable estimate of time and resources.

Technical Summary: LASER – Language Model Regression for Semi-Structured Workflow Resource and Runtime Estimation

Problem Statement

Accurate prediction of runtime and resource consumption (CPU, memory, disk) for cloud workflow jobs is essential for efficient scheduling, cost control, and infrastructure planning. Mispredictions lead to either over-provisioning (wasting compute resources) or under-provisioning (causing job failures and costly re-runs).

Current approaches treat this as a tabular regression problem, requiring brittle feature engineering to flatten complex, semi-structured job configurations into fixed-size vectors. These configurations include shell commands, tool-specific parameters, dependency graphs, and hierarchical metadata. Traditional methods struggle with:

Semantic Loss: Hand-coding features often fails to capture critical semantic context (e.g., the difference between aarch64 and x86_64 targets).
Fragility: Pipelines break silently when new tools or commands appear, a common occurrence in evolving cloud services.
Assumption Violations: Many methods rely on linear input-size-to-runtime assumptions that do not hold for heterogeneous workloads like chip design or CI/CD.
Data Limitations: Existing public datasets often lack the semantic diversity required to train models on real-world, heterogeneous workflows.

Methodology: The LASER Framework

LASER (Language model-bAsed regreSsion for sEmi-structured workflow job Resource and runtime estimation) reframes resource prediction as a sequence-to-sequence generation task. Instead of feature engineering, it fine-tunes Large Language Models (LLMs) directly on serialized, raw job configurations to generate structured JSON outputs containing resource predictions.

The framework relies on three core technical innovations:

1. Scientific Notation Output Encoding

Resource metrics (e.g., memory from MB to TB, runtime from seconds to hours) span multiple orders of magnitude, causing instability in standard linear regression heads.

Approach: Targets are encoded as fixed-length sequences of 8 tokens in scientific notation ( $m \times 10^e$ ), where the mantissa $m \in [1.00, 9.99]$ and exponent $e \in \mathbb{Z}$ .
Benefit: This eliminates the need for per-target normalization and allows the model to learn consistent numerical representations across scales.
Tokenizer Constraint: The authors restrict experiments to tokenizers (Qwen-3, Gemma-3) that encode digits 0–9 as single tokens, ensuring the fixed-length encoding assumption holds.

2. Constrained Decoding with Deterministic Prefix Filling

Standard autoregressive decoding can produce malformed JSON or invalid numerical formats.

Approach: The output structure (JSON keys, delimiters, and scientific notation scaffolding) is known constants. The system partitions the output into deterministic tokens (filled directly without a forward pass) and generative tokens (the numerical digits generated by the model).
Benefit: This enforces structural validity by construction (preventing hallucinations) and reduces inference latency by over 30% by skipping forward passes for fixed structural tokens.

3. Full-Attention Fine-Tuning

Modern long-context LLMs often default to sliding-window attention to save compute.

Approach: LASER employs full-attention mechanisms during fine-tuning.
Rationale: Workflow configurations often contain predictive signals across distant fields (e.g., a compilation target specified early affecting a tool invoked later). Full attention ensures global context visibility, which sliding windows miss.

Experimental Setup and Datasets

The framework was validated on two distinct datasets:

ChipDV (Proprietary): Over 160,000 cloud jobs from an industrial chip design verification workflow. Configurations are highly sensitive; minor script changes can cause tenfold runtime increases.
GHARuntime (Public Benchmark): A new benchmark derived from GHALogs, containing 1.3 million CI/CD workflow execution records across 27,000+ GitHub repositories and 20 programming languages.

Baselines included human experts, historical maximums, and state-of-the-art tabular ML models (XGBoost, LightGBM, TabPFN).

Key Results

In-Distribution Performance

Superior Accuracy: LASER significantly outperformed human experts and historical baselines on the ChipDV dataset. For example, on the "ChipDV-Unseen" set, the Gemma-3-12B model achieved a Mean Absolute Error (MAE) of 23.76 minutes for runtime, compared to 53.60 minutes for human experts.
Model Scaling: Performance improved consistently with model size (from 270M to 12B parameters), with the largest models achieving the best results across all targets (runtime, CPU, RAM, disk).

Out-of-Distribution (OOD) Generalization

Temporal Drift: When tested on future jobs (up to 26 days ahead), LASER maintained stable accuracy for resource metrics (CPU, RAM, Disk), demonstrating it learned generalizable consumption patterns rather than overfitting to the training period.
Cross-Repository Generalization: On the GHARuntime benchmark, LASER showed strong data-scaling behavior. While small models underperformed tabular baselines with limited data (1k samples), LASER matched or surpassed TabPFN-v2.6 with 10k–100k training samples, whereas tabular methods plateaued early.

Efficiency and Ablation

Latency: Constrained decoding reduced inference time by 30–36% across different model sizes.
Attention Mechanism: Full-attention fine-tuning consistently outperformed sliding-window attention, particularly for smaller models (1B parameters), confirming the importance of global context.
Sequence Length: Accuracy improved with longer sequence lengths up to 2048 tokens, with diminishing returns beyond that point.

Significance and Claims

The paper claims to establish a new paradigm for LLM-based regression on semi-structured workflow data. Its primary contributions are:

Elimination of Brittle Feature Engineering: By treating raw configurations as text, LASER avoids the labor-intensive and fragile process of manual feature extraction, enabling generalization to new tools and commands.
Technical Novelty in Regression: The combination of scientific notation encoding and constrained decoding solves the specific challenges of numerical regression via generation (handling scale and validity).
New Benchmark: The release of GHARuntime provides the first large-scale, semantically rich public benchmark for workflow runtime prediction, addressing the lack of diverse datasets in the field.

The authors conclude that LASER demonstrates that fine-tuned LLMs can effectively serve as regressors for complex, semi-structured industrial workloads, outperforming both human heuristics and traditional tabular machine learning approaches.