💻 computer science

Towards Energy-aware Requirements Dependency Classification: Knowledge-Graph vs. Vector-Retrieval Augmented Inference with SLMs

This paper proposes and empirically evaluates an energy-aware framework that compares Knowledge Graph-based and Vector-based retrieval methods to enhance the sustainability and accuracy of Small Language Models (7B–8B) in detecting conflicting software requirements.

Original authors: Shreyas Patil, Pragati Kumari, Novarun Deb, Gouri Ginde

Published 2026-03-26

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Shreyas Patil, Pragati Kumari, Novarun Deb, Gouri Ginde

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 head chef of a massive, chaotic kitchen. Every day, hundreds of new recipe requests (called Requirements) come in. Your job is to spot which recipes contradict each other before you start cooking. For example, one request says, "The cake must be baked at 400°F," while another says, "The cake must be baked at 200°F." If you don't catch this conflict early, you waste ingredients, time, and energy.

In the world of software, this is called Requirements Engineering. Traditionally, humans did this checking, which is slow and tiring. Recently, we started using super-smart AI chefs (called Large Language Models or LLMs) to do it for us. But here's the catch: these super-AIs are like giant, gas-guzzling trucks. They are incredibly powerful, but they burn a massive amount of electricity and produce a lot of carbon pollution just to think about a single sentence.

This paper asks a simple but crucial question: Can we use smaller, more efficient AI chefs (called Small Language Models or SLMs) to do the same job without wasting the planet's energy?

To answer this, the researchers tried two different ways to help these small chefs find the right information before they start cooking.

The Two Search Strategies

Imagine the small chef needs to check if a new recipe conflicts with old ones. They have to look through a giant library of past recipes.

1. The "Keyword Search" (Vector Retrieval - VSR)
This is like using a standard library catalog. You type in a few words, and the computer finds books that sound similar.

The Metaphor: If you ask for "Apple," the computer might bring you a book about Apple Inc. (the tech company) and a book about Apple Pie. It sees the word "Apple" and assumes they are related.
The Problem: In software, this is "structurally blind." It might miss that one recipe says "Add salt" and another says "Do not add salt" because the words are slightly different, or it might get distracted by irrelevant details. It's fast, but it can be a bit clumsy.

2. The "Expert Librarian" (Knowledge Graph Retrieval - KGR)
This is like having a super-organized librarian who understands how things connect. Instead of just matching words, this librarian builds a map of relationships.

The Metaphor: The librarian knows that "Salt" is an ingredient, "Add" is an action, and "Do not" is a negation. If you ask about "Adding salt," the librarian immediately pulls up the recipe that says "Do not add salt" because they understand the logic of the sentence, not just the words.
The Benefit: It's much smarter at finding actual conflicts, even if the wording is tricky.

The Experiment: Speed vs. Smarts vs. Green Energy

The researchers set up a race between these two methods using small AI chefs (models with 7–8 billion "brain cells," which is small for AI standards). They measured three things:

Accuracy: Did the AI find the conflict?
Speed: How long did it take?
Green Score: How much electricity and carbon did it use?

They also tested three different ways of talking to the AI (Prompting):

Zero-Shot: Just giving the task ("Find the conflict").
Few-Shot: Giving the AI a few examples first ("Here is an example of a conflict...").
Chain-of-Thought: Asking the AI to "think out loud" before answering.

The Surprising Results

Here is what they found, translated into everyday terms:

1. The "Smart Librarian" (KGR) Wins on Energy
In most cases, the Knowledge Graph (KGR) method was the clear winner for the environment.

Why? Even though building the "map" takes a little effort upfront, it helps the AI chef skip the wrong books entirely. It filters out 50% of the unnecessary work before the AI even starts thinking.
The Result: By using KGR, they saved about 75% of the energy and 80% of the carbon emissions compared to the standard "Keyword Search" (VSR), while still finding almost all the conflicts. It's like taking a shortcut that saves you a full tank of gas.

2. The "Keyword Search" (VSR) Only Wins in Huge Libraries
The only time the standard search was better was in the biggest dataset (IBM-UAV), which is like a library with millions of books. In that massive crowd, the "Keyword Search" was slightly faster and used less energy. But for normal-sized projects, the "Smart Librarian" was far superior.

3. Talking to the AI Matters (Prompting)

Zero-Shot (Just the task): This was the most energy-efficient way to talk to the AI. It was fast and clean.
Few-Shot (Giving examples): This doubled the amount of text the AI had to read, using more energy without always getting better results. It's like reading a whole textbook just to answer one question.
Chain-of-Thought (Thinking out loud): This helped the AI get smarter (better accuracy) but made it work much harder, burning more energy.

The Big Takeaway

The paper concludes that to make software development green and sustainable, we shouldn't just rely on bigger, hungrier AI models. Instead, we should:

Use Smaller Models: Switch from the "gas-guzzling trucks" (LLMs) to "hybrid cars" (SLMs).
Organize First: Use a Knowledge Graph (the Smart Librarian) to organize information and filter out the noise before the AI starts working.
Keep it Simple: Don't over-complicate the instructions (prompts) to the AI.

The Final Analogy:
Imagine you need to find a specific needle in a haystack.

The Old Way: Bring in a giant, hungry robot (LLM) to eat the whole haystack to find the needle. It gets the job done, but it eats a lot of fuel.
The New Way (This Paper): Use a magnet (Knowledge Graph) to pull out all the metal junk first, leaving you with a tiny pile of hay. Then, use a small, efficient robot (SLM) to find the needle in that tiny pile.
The Result: You find the needle just as fast, but you used 80% less fuel and saved the environment.

This research provides a blueprint for building software tools that are not only smart but also kind to our planet.

1. Problem Statement

The identification and classification of conflicting requirements in software engineering is a critical but labor-intensive task. While Large Language Models (LLMs) have shown promise in automating this, their massive computational requirements lead to excessive energy consumption and carbon emissions, making them unsustainable for large-scale deployment.

The core challenge addressed by this research is twofold:

Sustainability: How to perform accurate requirement dependency classification (specifically detecting "Conflict" vs. "Neutral" relationships) using resource-efficient Small Language Models (SLMs) (7B–8B parameters) rather than massive LLMs.
Retrieval Efficiency: How to augment these SLMs with context without incurring high energy costs. The paper compares two retrieval paradigms:
- Vector-based Semantic Retrieval (VSR): Uses dense embeddings (e.g., Sentence-Transformers) but suffers from "structural blindness," failing to capture hierarchical dependencies.
- Knowledge Graph-based Retrieval (KGR): Uses structured graphs to capture explicit entity relationships (actors, actions, conditions) but may be computationally intensive during indexing.

The study aims to determine which retrieval strategy offers the best trade-off between predictive accuracy (F1-score) and environmental impact (energy, latency, carbon emissions).

2. Methodology

A. Experimental Setup

Datasets: The study utilized five heterogeneous datasets spanning safety-critical, healthcare, and aerospace domains: OpenCOSS, WorldVista, UAV, PURE, and IBM-UAV. These datasets contain requirement pairs labeled as either "Conflict" or "Neutral."
Models: Three open-source SLMs were evaluated: DeepSeek-Coder-7B, Meta-Llama-3-8B, and Mistral-7B.
Prompting Strategies: The models were tested under three prompting conditions: Zero-Shot, Few-Shot, and Chain-of-Thought (CoT).
Infrastructure:
- Retrieval: Local execution on a Mac Mini M4 (Neo4j for KGR, Milvus for VSR).
- Inference: Cloud execution on Google Colab (NVIDIA A100 GPU).
- Measurement: Energy and carbon emissions were tracked using CodeCarbon, focusing strictly on the inference phase to ensure reproducibility.

B. Proposed Frameworks

Knowledge Graph-based Retrieval (KGR):
- Extraction: Uses spaCy to extract structured entities (Actor, Action, Object, Attribute, Condition) from requirements.
- Graph Construction: Requirements and entities are stored in a Neo4j graph. Relationships are defined by shared entities.
- Scoring: A candidate retrieval score is calculated based on three signals:
  - Entity Overlap: Number of shared entities.
  - Role Agreement: Consistency of semantic roles (e.g., same actor performing the same action).
  - Graph Proximity: Inverse of the shortest path distance between nodes.
- Output: Top- $k$ structurally relevant candidates are fed to the SLM.
Vector-based Semantic Retrieval (VSR):
- Embedding: Requirements are embedded using all-mpnet-base-v2 (768 dimensions).
- Indexing: Stored in a Milvus vector database using IVF_FLAT indexing with cosine similarity.
- Output: Top- $k$ semantically similar candidates are fed to the SLM.
Baseline: A "Vanilla" exhaustive inference approach where the SLM evaluates all possible requirement pairs without retrieval pruning (used for theoretical energy comparison).

C. Evaluation Metrics

Performance: Macro-averaged Precision, Recall, and F1-score.
Retrieval Efficiency: Recall@K (ability to retrieve the correct conflicting requirement within the top $K$ candidates).
Sustainability:
- Energy consumption (kWh).
- Latency (seconds).
- Carbon emissions (kgCO2eq).
- EcoScore: A novel metric defined as $\frac{\sum F1_{macro}}{\sum Carbon}$ , measuring performance per unit of carbon emitted.

3. Key Contributions

First Systematic Empirical Comparison: The study provides the first direct comparison of KGR vs. VSR specifically for energy-aware requirement dependency classification using open-source SLMs (7B–8B).
Novel KGR Pipeline: Introduces a structured retrieval pipeline that overcomes the "structural blindness" of vector embeddings by leveraging entity-centric graph traversal, which is crucial for detecting subtle logical contradictions.
Sustainability Framework: Proposes a three-pillar evaluation framework (Energy, Latency, Carbon) alongside accuracy, introducing the EcoScore to quantify the sustainability-to-performance ratio.
Open Science: The authors released a complete replication package, including source code, prompts, and sensitivity analysis.

4. Key Results

A. KGR vs. VSR (RQ1)

Small-to-Medium Datasets (OpenCOSS, UAV, WorldVista, PURE):
- KGR significantly outperforms VSR in sustainability. It reduced energy consumption by 71–75% and carbon emissions by up to 80% compared to VSR.
- Accuracy: KGR maintained comparable Recall@K (difference $\le$ 5%) to VSR.
- Trade-off: KGR incurred a latency overhead of ~45–48%, but the environmental savings were substantial.
Large-Scale Dataset (IBM-UAV):
- In this high-depth retrieval scenario ( $K=20$ ), VSR became more competitive, showing slightly higher recall and 15% lower energy consumption than KGR. This suggests vector indexing scales better for very dense, large corpora where graph traversal becomes computationally heavy.

B. Prompting Strategies (RQ2)

Zero-Shot was the most energy-efficient strategy, minimizing token usage and carbon emissions while often achieving competitive F1 scores (especially for Mistral and DeepSeek).
Few-Shot nearly doubled token usage and increased carbon emissions by ~5–6% without consistent accuracy gains.
Chain-of-Thought (CoT) improved accuracy for Llama models but incurred moderate energy penalties.
Best Configuration: Mistral-7B with Zero-Shot offered the best overall sustainability-performance balance (Highest EcoScore).

C. Sustainability-to-Performance Ratio (RQ3)

By using retrieval-augmented pipelines (KGR/VSR) to prune the search space, the system reduced the number of inferences required by 51.8% (from ~35,500 pairs to ~17,100).
This resulted in a 51.8% reduction in total energy consumption and carbon emissions compared to an exhaustive vanilla baseline, while preserving or improving classification accuracy.

5. Significance and Conclusion

This research demonstrates that structured retrieval (KGR) is a superior approach for sustainable Requirements Engineering in most contexts, particularly for small-to-medium datasets. It proves that:

SLMs are viable for complex RE tasks if augmented with the right context.
Retrieval architecture matters: Structured graph traversal provides better environmental efficiency than dense vector search for detecting logical conflicts, as it reduces the "search space" the model must process.
Prompting is a sustainability lever: Simple Zero-Shot prompts are often more sustainable than complex Few-Shot or CoT prompts without sacrificing performance.

The study concludes that future sustainable NLP systems should prioritize pre-inference search-space reduction (via structured retrieval) over increasing reasoning verbosity (via complex prompting) to achieve green AI goals in software engineering.