💻 computer science

Knowledge-Graph-Guided Retrieval-Augmented LLMs for Explainable Root Cause Analysis in Automotive HiL Validation

This paper proposes a knowledge-graph-guided retrieval-augmented large language model framework that transforms automotive Hardware-in-the-Loop time-series data into compact diagnostic evidence enriched with functional relationships and historical cases to achieve explainable, generalizable, and high-accuracy root cause analysis and fault localization.

Original authors: Hamza Ouarrad, Mohammad Abboush, Andreas Rausch

Published 2026-08-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Hamza Ouarrad, Mohammad Abboush, Andreas Rausch

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 a detective trying to solve a mystery, but instead of a crime scene, your "crime" is a glitchy car computer. In the world of building safe cars, engineers don't just drive them around; they put the car's brain (the computer) into a giant simulator called "Hardware-in-the-Loop" (HiL). It's like a video game where the real car computer is plugged in, but the road, the engine, and the weather are all made of math. This setup generates mountains of data—thousands of numbers changing every second, like a heartbeat monitor for a car that never actually moves.

The problem is that when something goes wrong in this simulation, the data just looks like a chaotic scribble. Old-school tools are like a flashlight that only tells you, "Hey, something is weird here!" but they can't tell you where the problem started or why. They are great at spotting the smoke, but terrible at finding the fire. Recently, scientists have started using "Large Language Models" (LLMs)—the super-smart AI brains that can write poems or chat with you—to help. But usually, these AIs are like guessers; they might hallucinate a solution or get confused by the sheer volume of numbers. To fix this, researchers are trying to teach these AIs to use a "Knowledge Graph," which is basically a giant, organized map of how every car part connects to every other part. The big question is: Can we combine this map with the AI's brain to not just find the glitch, but explain exactly what happened, like a seasoned mechanic?

This paper introduces a clever new system that acts like a detective with a superpower: it doesn't just look at the messy numbers; it translates them into a short, easy-to-read "diagnostic report" first. Think of it like this: instead of handing a detective a 10,000-page transcript of a phone call, you give them a one-page summary that says, "The caller sounded angry at minute 5, then the line went quiet at minute 10." The system takes the raw, chaotic car data and turns it into these compact clues, such as "this signal jumped up too fast" or "this sensor reacted 2 seconds later than it should have."

Once the clues are ready, the system does two smart things. First, it consults its "Knowledge Graph"—the map of the car's anatomy—to see which parts are physically connected. If the engine speed sensor acts up, the map knows that the fuel pump and the exhaust might be affected next. Second, it acts like a librarian, searching through a database of past car glitches to find similar cases. It asks, "Have we seen this specific pattern of clues before?"

Finally, it hands all this organized evidence—the summary clues, the connection map, and the past cases—to the AI (the LLM). The AI doesn't just guess; it acts as a reasoning engine. It looks at the evidence and says, "Okay, the engine speed sensor reacted first, and the map says it's connected to the throttle, and we found a similar case from last week where the throttle was the culprit. So, I'm 90% sure the throttle is the root cause." The paper tested this on two different car systems: a gasoline engine and an electric vehicle. The results were impressive. The system correctly identified the exact location of the fault 90% of the time for the gas engine and 94% of the time for the electric car. Even better, when the system looked at the whole test run instead of just tiny snippets of time, it got the answer right 100% of the time in the tests they ran.

The authors are careful to note that this isn't a magic wand that solves every car problem in the world yet. They tested it on specific types of glitches (called "gain faults," where a signal gets too strong or too weak) and on a relatively small set of test data. They also point out that if two things break at the exact same time, it might be harder to untangle. However, the study suggests that by giving the AI a structured map and a way to learn from past cases, we can move from just "detecting" errors to truly "diagnosing" them, making the process of building safer cars faster and more understandable for human engineers.

Technical Summary: Knowledge-Graph-Guided Retrieval-Augmented LLMs for Explainable Root Cause Analysis in Automotive HiL Validation

1. Problem Statement

Hardware-in-the-Loop (HiL) validation of automotive software systems generates vast amounts of multivariate time-series data. While current industry tools effectively detect anomalies using rule-based thresholds, they struggle with Root Cause Analysis (RCA) and fault localization. Validation engineers must manually correlate signal deviations with system architecture, historical cases, and component dependencies to identify where a fault originated and why.

Existing deep learning approaches for Fault Detection and Diagnosis (FDD) often treat localization as a classification task, requiring task-specific retraining when new faults or systems are introduced. Furthermore, these models typically lack explicit representation of the spatial and functional relationships between sensors, fault locations, and downstream propagation effects. They often fail to distinguish between a direct fault source and a propagated symptom, limiting their generalizability and utility for engineering diagnosis. Additionally, while Large Language Models (LLMs) offer reasoning capabilities, standard diagnostic applications often use them as end-to-end classifiers without grounding them in structured diagnostic evidence or engineering knowledge, leading to potential hallucinations and a lack of explainability.

2. Methodology

The paper proposes a Knowledge-Graph (KG)-guided Retrieval-Augmented Generation (RAG) framework. This approach shifts the role of the LLM from a direct time-series classifier to an evidence-fusion and reasoning layer. The pipeline consists of four main stages:

A. Preprocessing and Diagnostic Evidence Extraction

Raw multivariate HiL recordings are not fed directly into the LLM. Instead, they are converted into compact, structured diagnostic evidence by comparing faulty recordings against time-aligned healthy reference runs.

Windowing: Data is segmented into windows (e.g., 5 seconds) to capture temporal dynamics.
Feature Engineering: For each signal, the system calculates:
- Raw mean deviation ( $\Delta\mu$ ).
- Normalized mean-shift z-score ( $z$ ) to handle different signal scales.
- Maximum deviation z-score.
- First abnormal reaction time (critical for distinguishing direct faults from propagation).
- An overall abnormality score combining persistent and peak deviations.
Ranking: Signals are sorted by abnormality score to identify the most relevant direct and propagated deviations.

B. KG-Guided Candidate Ranking

A Knowledge Graph encodes domain-specific relationships, including:

Signal-to-Fault Mappings: Which signals represent specific fault locations (e.g., battery voltage for HV battery faults).
Propagation Relations: How faults propagate through subsystems (e.g., from battery to DC-link to motor).
Evidence Scoring: A score $S_{evid}(c)$ is computed for each candidate fault location $c$ by weighting evidence from primary signals, direct signals, and propagation signals. Primary and direct evidence are weighted more heavily than propagation evidence to prevent downstream symptoms from dominating the diagnosis.

C. Retrieval-Augmented Generation (RAG)

The framework retrieves similar historical fault cases to support reasoning.

Vector Representation: The extracted diagnostic evidence (z-scores, reaction times) forms a query vector.
Similarity Search: Cosine similarity is used to find the top- $k$ most similar historical cases from a case library.
Leave-One-Recording-Out (LORO): To prevent data leakage, windows from the current test recording are excluded from the retrieval library and few-shot examples during inference.

D. LLM Reasoning and Prediction

The LLM acts as a reasoning engine that synthesizes:

The query's structured diagnostic evidence.
KG facts (sensor-fault mappings and propagation paths).
Retrieved historical cases.
Few-shot examples demonstrating the reasoning pattern.

The LLM is instructed to output a ranked list of fault locations (Top-1 and Top-3) accompanied by an interpretable RCA explanation in a strict JSON format. It is explicitly guided to prioritize direct evidence over propagation effects. Finally, for file-level diagnosis, predictions from multiple windows within a recording are aggregated using rank-based voting to produce a stable final diagnosis.

3. Key Contributions

Novel Framework: The first study to unify automotive HiL recordings, structured diagnostic evidence extraction, case-based retrieval, knowledge-guided diagnosis, and Retrieval-Augmented LLMs into a single framework for fault localization.
Evidence Extraction Module: A method to convert raw time-series data into interpretable features (abnormality scores, reaction times, deviation directions) that drive the retrieval and reasoning process.
Lightweight Case-Based Retrieval: A retrieval mechanism based on engineered diagnostic features rather than semantic embeddings, combined with KG constraints to capture sensor-location relationships.
Reasoning Layer: An LLM architecture that functions as an evidence-fusion and reranking layer, producing ranked hypotheses with engineering explanations rather than acting as a black-box classifier.

4. Experimental Results

The framework was evaluated on two automotive HiL case studies:

ASM Gasoline Engine: 5 fault locations (e.g., accelerator pedal, engine speed).
Electric Vehicle (EV) System: 3 fault locations (e.g., HV battery, rear motor speed).

Performance Metrics:

Accuracy: The best-performing models (Gemma-3 27B and Qwen3 32B) achieved Top-1 accuracies of 90% (ASM) and 94% (EV).
Top-3 Accuracy: Reached 100% for both case studies, indicating the correct fault was always within the top three candidates.
Aggregation: While window-level Top-1 accuracy was 83.3% (ASM) and 94.4% (EV), recording-level aggregation (voting across windows) achieved 100% Top-1 accuracy for both systems. This demonstrates that aggregating predictions mitigates local ambiguities caused by propagation effects.
Retrieval: Structured "z-only" diagnostic representations outperformed raw numerical vectors and text embeddings in retrieving relevant historical cases.
Efficiency: Gemma-3 27B was identified as the optimal model, matching the accuracy of Qwen3 32B but requiring approximately 28% less inference time (4.77s vs 6.61s per prompt).

5. Significance and Claims

The paper claims that this framework addresses a significant gap in automotive validation by providing explainable and generalizable root cause analysis without the need for retraining on new fault types.

Explainability: Unlike black-box classifiers, the system provides a ranked list of candidates with explicit reasoning (e.g., "identified as root cause due to direct signal deviation, while other signals are propagation effects").
Generalizability: The method transfers effectively between different vehicle architectures (Gasoline vs. EV) because it relies on structured diagnostic evidence and KG mappings rather than learning specific signal patterns from scratch.
Safety-Critical Grounding: By using the LLM as a reasoning layer grounded in structured evidence and KG constraints, the approach mitigates hallucinations common in pure LLM applications, making it more suitable for safety-critical contexts.

The authors acknowledge limitations, noting the current dataset is limited in size and focuses primarily on single gain faults. Future work is proposed to extend the framework to concurrent faults and integrate more dynamic causal representations.