Papers for

edge ai engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Trust challenges and solutions for offline generative AI on Raspberry Pi 5

Trust Mechanisms for Offline Generative AI at the Edge: A Connectivity-Regime Framework and an Empirical Study on a Raspberry Pi 5

Abstract: Generative AI and large language models (LLMs) are moving into the Internet of Things, yet most deployments assume cloud connectivity, and many IoT settings have intermittent, restricted, or no connectivity. We propose a connectivity-regime framework (C0-C4), a taxonomy of inference-time trust mechanisms, and signed, versioned knowledge packs as the update channel for disconnected regimes, and evaluate them on a Raspberry Pi 5 running fully local retrieval-augmented generation under network isolation, with three Qwen2.5 model sizes, three context sizes, and 300 SQuAD 2.0 questions. An empirically calibrated retrieval-score gate detects knowledge gaps almost perfectly (AUROC 0.97) but in-topic unanswerable questions poorly (0.68). A deterministic output validator converts malformed outputs into explicit abstentions with no observed loss of correct answers, while the NLI-based verifier we tested adds little; for the 7B model, 96% of substantive answers to unanswerable-labelled questions match normalized spans of the retrieved passages. A 3B model achieves the same gold-answer containment rate as a 7B model at less than half the latency and estimated energy, although the 7B model far more often exceeds a token-F1 threshold of 0.5; five retrieved passages lower correctness from 75% to 52% compared with three. Verifying a signed pack takes about 4.5 ms versus about 29 min for embedding its passages on the device; signature and hash checks alone accept six of nine tested update attacks that layered verification rejects. Yet a validly signed poisoned pack passes every pack check: on 30 previously correct questions, correct answers drop to zero and 14 return the injected answer. None of the mechanisms we evaluated establishes the truth of the evidence. We release code and data.

Sat 24 OctCryptography and SecurityArtificial IntelligenceMachine Learning
The gist
Generative AI usually depends on internet connections to get updates and verify information, but some devices like those in Internet of Things (IoT) settings have poor or no connectivity. The authors study how to trust AI models running entirely offline on a small computer called Raspberry Pi 5. They test various ways to detect when the AI doesn't know enough or gives wrong answers, including checks on its outputs and updates. While some methods reduce errors or catch corrupted updates, none can guarantee the truthfulness of the AI's information without connectivity.
Open → 2610.33732v1

Federated LoRA improves sharing by aligning client input patterns

What Should Federated LoRA Share? FedSAIL via Input-aware Subspace Alignment

Abstract: Federated low-rank adaptation (LoRA) requires identifying an update structure that is shared across heterogeneous clients. Prior work reports strong similarity among trained LoRA projection matrices across clients; however, such agreement may be largely induced by common initialization and collapses toward random overlap under independent initialization. More crucially, relying solely on parameter similarity inherently ignores the influence of local input regime. To uncover a more robust shared structure, we introduce an input-aware action matrix that weights the adapter update by the second-moment statistics of local layer inputs. Empirically, while parameter similarity vanishes, the leading right singular directions of this action matrix remain strongly aligned across clients. This shared geometry preserves task-conditioned differences and naturally varies across network depths. Motivated by these findings, we propose Federated Subspace-Guided Action-Informed Learning (FedSAIL). Instead of averaging weights, FedSAIL estimates a shared action subspace to regularize local training while preserving client-specific coefficients. Across several benchmarks, our approach consistently improves predictive performance over competing federated LoRA methods while reducing communication cost significantly.

Sat 26 SeptMachine Learning
The gist
Training AI models with different groups of devices (clients) working together can be tricky because each group sees different data. Previous methods tried to share parts of the model that looked similar across groups, but this wasn’t reliable when starting from scratch. The authors found that looking at how the input data influences the model’s updates reveals hidden patterns that are more consistent across clients. They created a method called FedSAIL that uses these shared patterns to guide learning, resulting in better performance and less data sent between devices.
Open → 2609.32485v1

Hyperdimensional computing speeds up multiple query processing together

Superposed Inference for Hyperdimensional Computing

Abstract: Hyperdimensional computing (HDC) is attractive for efficient and robust learning, but conventional inference still encodes every query independently, repeatedly paying the cost of high-dimensional projection. We introduce SupHDC, a new inference paradigm that processes multiple queries through a shared encoding computation. SupHDC assigns lightweight random slot keys, superposes the keyed queries before encoding, and uses slot-specific classifiers to recover their individual predictions. A random-feature kernel view explains why exact recovery of each hypervector is unnecessary: inference only needs to preserve the class evidence that determines the prediction. Across ten datasets, SupHDC achieves 1.39x analytical speedup with no average accuracy loss, and up to 2.08x speedup with only a 2.67 percentage-point mean accuracy loss. On a Raspberry Pi~5, it delivers 2.01x measured wall-clock speedup with a 2.26 percentage-point loss in mean prediction accuracy. SupHDC shows that high-dimensional redundancy can be used not only for robustness, but also as capacity for shared inference.

Sat 26 SeptMachine LearningArtificial Intelligence
The gist
Hyperdimensional computing is a way to quickly and reliably learn from data, but it usually has to process each new question one by one, which can be slow. The authors introduce a method called SupHDC that combines several questions before processing, saving time by sharing calculations. They use special keys to keep each question recognizable and separate, so predictions stay accurate. Their tests show faster speed with little to no loss in accuracy, including on small devices like Raspberry Pi.
Open → 2609.32320v1

Llm agents automate model conversion across multiple edge AI runtimes

From PyTorch to the NPU: LLM-Agent-Driven Model Conversion Across Heterogeneous Inference Runtimes

Abstract: Edge AI model deployment is a multi-stage engineering process involving model conversion, operator compatibility handling, runtime integration, and precision verification. While prior work has demonstrated agent-based automation for Qualcomm AI Runtime, the broader edge inference runtime ecosystem, including Intel OpenVINO, Rockchip RKNN, NVIDIA TensorRT, and ONNX Runtime, presents distinct toolchains and optimization strategies. This paper extends AIPC (AI Porting Conversion, an LLM agent-driven methodology for AI model deployment automation previously demonstrated on Qualcomm AI Runtime) to multi-runtime scenarios, proposing an LLM agent-driven approach for automated single-model-to-single-runtime deployment across heterogeneous inference backends, such as Intel OpenVINO, Rockchip RKNN, NVIDIA TensorRT, and ONNX Runtime. We decompose the edge AI deployment into standardized, verifiable stages, and inject runtime-specific domain knowledge into the agent execution flow through agent skills, auxiliary scripts, and staged verification loops. Using representative vision models, we demonstrate that agent-based deployment can complete the conversion from a PyTorch model to its executable inference, targeting OpenVINO for x86/NPU, RKNN for RK3588, TensorRT for NVIDIA GPU, and ONNX Runtime for Qualcomm NPU with a focus on FP16 precision deployment feasibility verification. The contributions of this paper primarily lie in providing multi-runtime deployment engineering practice experience, toolchain mapping analysis, a layout-adaptation and inference-replacement layer that removes manual transpose insertion from the agent's repair burden, and an empirical characterization of agent deviation behavior under structured knowledge injection, rather than large-scale systematic benchmarking or cross-runtime operator repair strategy comparison.

Wed 23 SeptSoftware EngineeringDistributed, Parallel, and Cluster Computing
The gist
Deploying AI models on different devices often involves many tricky steps like changing model formats and making sure they run correctly. The authors show how large language model (LLM) agents can automate this process across several popular AI runtimes, such as those from Intel, NVIDIA, and Qualcomm. They break down deployment into clear stages and teach the agent how to handle specific runtime requirements to convert a model from PyTorch into an executable form with less manual work. Their work focuses on engineering practice and how to guide the agent reliably, rather than comparing runtime performance or repair strategies.
Open → 2609.27249v1