🤖 machine learning

SDVDiag: Using Context-Aware Causality Mining for the Diagnosis of Connected Vehicle Functions

This paper introduces SDVDiag, a multimodal diagnostic framework for connected vehicle functions that combines Reinforcement Learning from Human Feedback with distributed tracing and domain expertise to significantly improve causal error detection precision and system interpretability compared to purely data-driven methods.

Original authors: Matthias Weiß, Falk Dettinger, Elias Detrois, Nasser Jazdi, Michael Weyrich

Published 2026-04-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Matthias Weiß, Falk Dettinger, Elias Detrois, Nasser Jazdi, Michael Weyrich

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 mechanic for a massive, self-driving valet parking lot. Instead of just one car, you have a fleet of robots moving around, talking to each other, and coordinating with a cloud "brain" to park cars perfectly.

Now, imagine one of these robot cars suddenly stops in the middle of the driveway, refusing to move, even though there are empty spots right next to it.

The Problem: The "Black Box" Mystery
In the old days, if a car broke down, a mechanic could pop the hood, look at the engine, and fix it. But in this modern, connected world, the "engine" is spread out across the car, the parking lot's Wi-Fi, and a giant cloud server. When things go wrong, it's like a game of "telephone" gone wrong. The car says, "I stopped because the server didn't talk to me," but the server says, "I talked to the Wi-Fi, but the Wi-Fi was busy."

Trying to figure out who actually caused the crash is incredibly hard. Old computer programs try to solve this by looking at millions of data points (like CPU usage or network speed) and guessing patterns. But these programs are like a detective who only looks at footprints but ignores the suspect's alibi. They often guess wrong, creating a long list of "maybe it was this, maybe it was that" suspects, most of whom are innocent.

The Solution: SDVDiag (The Smart Detective)
The paper introduces a new system called SDVDiag. Think of it as a detective who doesn't just look at footprints but also has a team of human experts and a map of the crime scene.

Here is how it works, broken down into three simple steps:

1. The "Gut Check" (Reinforcement Learning with Human Feedback)

Imagine the computer is a student learning to solve mysteries.

The Old Way: The student looks at data and guesses. It gets it wrong a lot.
The New Way: The computer makes a guess, and then a human expert (the senior detective) says, "No, that connection doesn't make sense. Try this one instead."
The Magic: The computer doesn't just take the answer; it learns why the expert said no. It uses a technique called Reinforcement Learning. It's like playing a video game where the human expert gives you points for good guesses and takes them away for bad ones. Over time, the computer gets really good at spotting the real connections and ignoring the noise.

2. The "Phone Call Check" (Context-Aware Pruning)

Even with a smart student, sometimes the data is tricky. Two things might happen at the same time just by coincidence (like it raining and a traffic jam happening), but one didn't cause the other.

The Trick: SDVDiag has a special tool called Distributed Tracing. Think of this as a "phone log" that records every single conversation between the car, the server, and the Wi-Fi.
The Filter: If the computer thinks "Server A caused the crash," but the "phone log" shows Server A never actually called the part that crashed, SDVDiag says, "Wait a minute, that's impossible!" and deletes that guess. It prunes away the fake connections, leaving only the ones that actually happened.

3. The "Hidden Clue" Injection (Context Extension)

Sometimes, the real problem is something the computer can't see at all.

The Scenario: In the parking lot test, the real problem was a "queue overflow" (too many cars trying to park at once). But the computer's sensors didn't have a specific gauge for "queue overflow." It just saw the CPU getting hot.
The Fix: The human experts can write a simple rule: "If the CPU gets too hot, assume there is a hidden 'traffic jam' causing it."
The Result: The system injects this invisible "traffic jam" into the map. Now, when the computer analyzes the crash, it doesn't blame the CPU; it correctly blames the traffic jam. It connects the dots that were previously invisible.

The Result: From Guessing to Knowing

The researchers tested this on their automated valet parking system.

Before: The old computer methods were like a shotgun blast. They found 137 possible causes, but only 14% were actually right. It was a mess of false alarms.
After: With the new SDVDiag system (Human feedback + Phone logs + Hidden clues), they narrowed it down to just 16 causes. And guess what? 100% of those 16 were correct.

The Big Picture

This paper is about teaching computers to be better detectives. Instead of just crunching numbers, they now:

Listen to experts to learn what makes sense.
Check the logs to see what actually happened.
Use common sense (rules) to find hidden problems.

This means that when a connected car or a smart city system breaks, we won't have to wait days for a human to manually sort through the mess. We can fix it instantly, keeping our self-driving cars and smart cities running smoothly.

1. Problem Statement

Connected vehicle functions rely on complex, distributed architectures involving cloud, edge, and networking layers. While these systems offer advanced capabilities, their reliability is compromised by:

Distributed Complexity: Failures often stem from intricate error chains across multiple network layers and microservices.
Limitations of Data-Driven Diagnosis: Existing automated diagnosis tools are predominantly data-driven (statistical). They struggle with:
- Hidden Dependencies: They cannot easily detect causal links that are not explicitly visible in raw metrics.
- Context Integration: They fail to incorporate human expert knowledge or system-specific topology.
- Dynamic Adaptation: Frequent system updates and varying network conditions require constant retraining, which is impractical for continuous operation.
Manual Bottlenecks: Consequently, diagnosis often relies on manual expert intervention, leading to extended downtime and economic losses.

2. Methodology

The authors propose SDVDiag, a multimodal, context-aware framework that integrates automated data analysis with human feedback and domain knowledge. The pipeline consists of four main stages:

A. Data Collection and Encoding

Sources: The system ingests performance metrics (CPU, memory) from Prometheus and distributed traces (service communication flows) from Zipkin.
Graph Neural Network (GNN) Encoder: Raw time-series metrics are converted into vector embeddings using a GNN trained via contrastive learning.
- Goal: Services with causal relationships are mapped to similar vectors; unrelated services are mapped to distant vectors.
- Training: Uses initial causal graphs generated by standard algorithms (e.g., PC algorithm) as a "ground truth" for pre-training, allowing the encoder to operate without manual labeling initially.

B. Human Feedback Integration (Reinforcement Learning)

To overcome the inaccuracies of purely statistical inference, the system employs Hierarchical Reinforcement Learning (HRL) with Human Feedback:

Mechanism: Instead of asking experts to label every edge (which is $O(N^2)$ ), the system presents triplets (a target node and two candidate predecessors) for binary comparison.
Policies:
- Low-Level Policy ( $\pi_l$ ): Uses Deep Deterministic Policy Gradient (DDPG) to optimize edge probabilities based on expert pairwise comparisons.
- High-Level Policy ( $\pi_h$ ): Uses Q-learning to select the most informative target nodes for expert review, maximizing the value of each query.
Reward Model: A neural network approximates expert preferences, training the policies to refine the causal graph continuously. All feedback is stored persistently to allow incremental learning across system restarts.

C. Context-Aware Refinement

Before presenting the graph to engineers, a multimodal pruning and enrichment module is applied:

Pruning:
- Confidence Filtering: Removes low-probability edges.
- Trace Validation: Cross-references inferred edges against Zipkin data. If a statistical link exists between metrics but no actual service-to-service communication is recorded in the traces, the edge is discarded.
- Duplicate Aggregation: Consolidates multiple metric-level edges between the same services.
Enrichment (Context Extension):
- A rule-based interface allows experts to inject hidden causal relationships that do not appear in standard telemetry (e.g., a queue backlog).
- Example: A rule can trigger the injection of a "parking_queue" node if CPU utilization exceeds a threshold, connecting it to the affected service.
- Cycle Detection: Ensures the final graph remains a Directed Acyclic Graph (DAG).

3. Key Contributions

RL-Based Human Feedback Loop: A novel framework that efficiently incorporates expert knowledge into causal discovery using pairwise comparisons and hierarchical RL, preserving knowledge in a persistent database.
Multimodal Analysis Pipeline: Simultaneous processing of performance metrics (for dependency patterns) and distributed traces (for structural validation) to prune false positives.
Context-Aware Refinement: A rule-based interface that allows the injection of domain-specific knowledge and hidden system states, bridging the gap between statistical inference and physical system reality.

4. Results and Evaluation

The approach was evaluated using an Automated Valet Parking (AVP) application running on a Kubernetes cluster with a fleet of Unmanned Ground Vehicles (UGVs). The scenario simulated a queue overflow causing synchronization failures.

Precision Improvement:
- Raw (Base Policy): 14% precision (137 edges, many false positives).
- Feedback-Adjusted: 32% precision (49 edges).
- Final Pruned Graph: 100% precision (16 edges). All identified edges were confirmed as true causal relationships.
Recall: The final graph achieved 84% recall, correctly identifying 16 out of 19 expected causal edges. The missing edges were attributed to services with low invocation frequency during the test.
Root Cause Analysis: The context extension module successfully identified the queue overflow as the root cause (a hidden factor not directly monitored), whereas standard analysis would have only flagged downstream symptoms like high CPU load.
Interpretability: The final graph was significantly smaller and more interpretable than the raw statistical output, making it actionable for system operators.

5. Significance

Bridging the Gap: SDVDiag effectively bridges the gap between purely data-driven AI (which lacks context) and manual expert analysis (which is slow).
Operational Efficiency: By achieving 100% precision in causal edge detection, the system drastically reduces the time engineers spend investigating false alarms.
Handling Hidden Variables: The ability to inject context rules allows the system to diagnose issues caused by unmonitored components (e.g., message queues), a common blind spot in traditional observability.
Scalability Potential: While the current evaluation was on a small system (7 services), the modular design and persistent learning loop suggest potential for scaling to larger microservice architectures, provided the ground truth and expert feedback mechanisms are maintained.

Limitations & Future Work:
The authors note that the evaluation was limited to a small-scale system, and the "ground truth" relied on expert estimation rather than definitive causal knowledge. Future work aims to test scalability on larger systems, improve GNN embedding quality, and integrate logs and documentation for further interpretability.