💻 computer science

Enhancing SLMs for Sustainable Code Optimization in Radio-Astronomy

This paper proposes an energy-efficient AI-driven approach for sustainable code optimization in radio astronomy by enhancing Small Language Models (SLMs) with multi-sampling generation and compiler feedback, enabling them to match or surpass larger models while minimizing the environmental impact of the optimization process itself.

Original authors: Elisa Chiarotto, Jingbo Li, P. Chris Broekema, Rob V. van Nieuwpoort

Published 2026-07-27

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Elisa Chiarotto, Jingbo Li, P. Chris Broekema, Rob V. van Nieuwpoort

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 solve a massive, galaxy-sized puzzle. This isn't a jigsaw with a few hundred pieces; it's a puzzle with trillions of pieces, and the picture is the universe itself. This is the world of radio astronomy, where scientists use giant telescopes to listen to the whispers of the cosmos. But here's the catch: listening to the universe creates a mountain of data so huge that our computers are starting to sweat. To process this data, we need to write complex computer code. The problem is, the more powerful the code becomes, the more electricity it eats, and the more heat it generates. We are at a crossroads: we need to see deeper into space, but we can't afford to burn up the planet to do it.

To fix this, scientists are turning to Artificial Intelligence (AI) to help write and improve the code. Usually, the "super-smart" AI models are like giant, hungry monsters that need entire data centers to run, which defeats the purpose of saving energy. This paper asks a clever question: Can we use smaller, more efficient AI models—let's call them "smart little helpers"—to do the same job? The authors also explore a new way to teach these helpers. Instead of just asking them to write code and hoping for the best, they let the AI run the code, see where it breaks (like a compiler error), and then ask the AI to fix its own mistakes. It's like giving a student a test, showing them the red marks on their paper, and asking them to try again immediately. The goal is to see if these smaller, energy-efficient helpers, when given a second chance to learn from their errors, can outperform the giant, energy-hungry monsters.

The Paper: Teaching Small AI to Be Big and Green

In this study, the researchers at Leiden University and NWO-I ASTRON are tackling a very specific challenge: how to upgrade the software for the LOFAR radio telescope without breaking the bank on electricity. The telescope is getting a massive hardware upgrade, which means it will produce 40 times more data. If the software isn't optimized, the energy bill for processing that data would skyrocket. The team wants to use AI to help write better, faster code, but they are worried that the AI itself might use too much energy.

The First Experiment: The "Many Small Guesses" Strategy

The team wanted to see if a small AI model could beat a big one if they were given the same amount of time to work. Imagine you have a tiny, quick-witted friend (a 7-billion-parameter model) and a giant, slow-moving genius (a 32-billion-parameter model). Usually, the genius is better, but they take forever to think.

The researchers tried a trick with the tiny friend: instead of asking for just one answer, they asked for seven different guesses in the same amount of time it took the giant to make just one. It's like asking a fast runner to make seven short sprints while the slow giant takes one long, heavy walk.

The results were surprising. In the programming language Python, the tiny friend, making seven guesses, actually did a better job than the giant making one guess. It managed to write code that was just as good, if not better, while using only one graphics card (GPU) instead of four. In C#, the results were a bit more mixed, but the tiny friend still held its own. The key takeaway here is that by letting a small model try multiple times quickly, you can get high-quality results without needing the massive energy cost of a giant model.

The Second Experiment: The "Learn from Your Mistakes" Loop

The second part of the study looked at how to make these AI models even smarter by giving them feedback. Imagine you are writing a story, and every time you finish a paragraph, a strict editor hands it back and says, "You made a grammar mistake here," or "This sentence doesn't make sense." You then fix it and try again.

The researchers built a system where the AI writes code, runs it, and if the computer throws an error (like a syntax error or a logic bug), the AI reads that error message and tries to fix the code. They tested this with several different small AI models.

The findings were consistent: every single model got better when they were allowed to see their mistakes and fix them. On average, the models improved their success rate by 3 to 4 percentage points. One model, CodeGemma, saw a huge jump of 10 percentage points! This suggests that even a simple "try, fail, fix" loop can make a small AI much more reliable.

What They Found and What They Didn't

The paper suggests that we don't need to rely on massive, energy-guzzling AI models to optimize scientific code. Instead, using smaller models with a "multi-sampling" strategy (trying many times) and an "agentic" workflow (learning from compiler errors) can produce code that is just as good, if not better, while using a fraction of the energy.

However, the authors are careful not to claim this is a magic bullet. They note that while the small models performed well in these specific tests, they are still working on making the system even better. They haven't yet combined the "many guesses" strategy with the "learn from mistakes" loop, but they expect that doing both together would be even more powerful. They also point out that while the code generation improved, they are still working on how to measure the exact energy savings of the final code.

The Bottom Line

This paper shows a promising path forward for sustainable science. By using smaller, smarter AI models that are allowed to try multiple times and learn from their errors, scientists might be able to upgrade their massive telescopes and process the universe's data without increasing their carbon footprint. It's a reminder that sometimes, a small, quick, and persistent helper is better than a giant, slow, and expensive one.

Technical Summary: Enhancing SLMs for Sustainable Code Optimization in Radio-Astronomy

1. Problem Statement

The radio astronomy community, specifically regarding the LOFAR telescope and the upcoming LENSS project, faces a critical challenge: a projected 40-fold increase in computational requirements due to hardware upgrades and expanded observational capabilities. This increase must be managed within a strict, pre-established energy budget to ensure sustainability.

Current Large Language Models (LLMs) offer promise for automating code generation and optimization (e.g., porting to GPUs), but they are inherently resource-intensive. Inference alone can account for up to 90% of a model's lifecycle energy use. Relying on massive LLMs to optimize code for energy efficiency creates a paradox where the optimization process itself consumes excessive energy. Furthermore, general LLMs suffer from hallucinations, security risks, and logic errors, while specialized coding models may produce syntax errors or infinite reasoning loops.

The core problem is how to generate and optimize high-quality, sustainable code for large-scale scientific instruments without incurring the prohibitive environmental cost of using large-scale LLMs.

2. Methodology

The authors propose an AI-driven approach using Small Language Models (SLMs) enhanced by Agentic AI to assist developers in evaluating and optimizing code. The methodology focuses on two complementary strategies to improve SLM performance without increasing model size:

A. Multi-Sampling Generation Strategy

To address the performance gap between small and large models under fixed compute budgets, the authors compare a multi-sampling strategy on a smaller model against a single-generation strategy on a larger model.

Concept: Instead of generating one output from a large model, the system generates multiple candidates ( $k$ ) from a smaller model within the same time budget.
Selection: Candidates are evaluated using a selection strategy (e.g., highest log-probability or cosine similarity to ground truth) to identify the best solution.
Rationale: This leverages the statistical likelihood that repeated sampling from a smaller model can yield a correct solution comparable to a single pass from a larger model, but with significantly lower resource consumption.

B. Agentic AI with Compiler Feedback

The authors implement an agentic workflow (named SuperRAG) that integrates SLMs with external tools and domain knowledge.

Retrieval Augmented Generation (RAG): The system retrieves relevant domain-specific documents (architecture specs, source comments) to ground the model's output and reduce hallucinations.
Revision Loop: The agent operates in two roles: a "coder" (generating baseline code) and a "debugger" (fixing errors).
Feedback Mechanism: The system feeds compiler errors and unit test results back into the model as context. The model iteratively refines its code based on this feedback until it passes syntactic and semantic checks.
Future Integration: The framework is designed to eventually include dynamic analysis tools (e.g., Coz) for performance optimization and missed compiler remarks, though the current paper focuses on correctness via compiler feedback.

3. Key Contributions

Demonstration of SLM Efficiency: The paper shows that SLMs, when enhanced with multi-sampling, can match or surpass larger single-generation models in code completion tasks while using a fraction of the computational resources.
Compiler Feedback Integration: The authors demonstrate that incorporating compiler output as feedback in an agentic loop consistently improves code generation performance across various model families and sizes.
Sustainable Optimization Framework: The work proposes a "human-in-the-loop" approach where the AI provides suggestions and identifies bottlenecks rather than writing code directly. This aims to reduce technical debt and security risks while allowing developers to learn and maintain control.
Empirical Validation: The study provides quantitative evidence comparing Qwen2.5-Coder-7B (multi-sampled) against Qwen2.5-Coder-32B (single-generation) and evaluates the impact of compiler feedback on models ranging from 3B to 80B parameters.

4. Results

Multi-Sampling vs. Single Generation

Python Tasks: The 7B model (using 1 NVIDIA A100 GPU) outperformed the 32B model (using 4 NVIDIA A100 GPUs) across all 10 seed groups in the CrossCodeEval benchmark. The improvement was statistically significant ( $p = 0.000006$ ).
C# Tasks: The 7B model slightly outperformed the 32B model in 6 out of 10 groups, with the difference not being statistically significant ( $p = 0.18$ ).
Resource Efficiency: The 7B model achieved equivalent or better code quality using only one-quarter of the computational resources (1 GPU vs. 4 GPUs) and a lower generation-only runtime.
Upper Bound: A "best-cosine upper bound" analysis indicated that further improvements in the selection strategy could yield even higher performance.

Agentic AI with Compiler Feedback

Consistent Gains: Providing compiler errors as feedback consistently improved performance for all tested models (including CodeLlama, CodeGemma, and various Qwen models).
Magnitude of Improvement: Most models saw a performance gain of 3–4 percentage points on the validation set. CodeGemma showed a notable improvement of 10 percentage points.
Independence from Baseline: The performance gain appeared largely independent of the model's baseline performance, size, or family.
Error Analysis:
- Qwen2.5-Coder-3B: Primary errors were incorrect logic (50%) and hallucinated examples (20%).
- Qwen3-4B (Thinking): Primary errors were syntax errors (40%) and infinite thinking loops (20%).
- Hybrid Models: Using different models for coding and debugging roles did not yield better results than using a single model for both; performance tended to align with the debugger model's capabilities.

5. Significance and Claims

The paper claims that Small Language Models (SLMs) are a viable, sustainable alternative to Large Language Models for code optimization in scientific computing, provided they are enhanced with specific strategies.

Sustainability: By using SLMs with multi-sampling and agentic feedback, the environmental cost of the optimization process itself is minimized, aligning with the goal of reducing the carbon footprint of radio astronomy data processing.
Performance Parity: The authors demonstrate that "smaller is not necessarily worse." With the right architectural enhancements (multi-sampling and tool integration), a 7B model can compete with a 32B model while using 4x fewer resources.
Generalizability: The proposed approach is generic and can be extended to include Retrieval Augmented Generation (RAG), static analysis, and dynamic analysis tools (like Coz) to further refine code performance and optimization.
Human-Centric Design: The system is designed to assist developers rather than replace them, providing suggestions and debugging feedback to reduce technical debt and improve code understanding, rather than generating code autonomously which may introduce security risks.

The authors conclude that while they have not yet evaluated the combination of multi-sampling and agentic feedback, the independent success of both methods suggests that their combination will yield further benefits for sustainable code optimization in radio astronomy.