FEDML - The unified and scalable ML library for large-scale distributed training, model serving, and federated learning. FEDML Launch, a cross-cloud scheduler, further enables running any AI jobs on any GPU cloud or on-premise cluster. Built on this library, TensorOpera AI (https://TensorOpera.ai) is your generative AI platform at scale.
Code for reproducing the numerical simulations and reservoir computing analyses in "Regime-Dependent Memory–Nonlinearity Trade-Off in Kerr-Comb Reservoir Computing".
Skipping zero activations saves multiplications in CNN accelerators, but it complicates accumulation: the products in a compressed input window belong to different output columns and must be merged. In our earlier engine, this merging was done by read-modify-write (RMW) of a row buffer, which made sparse inputs slower than dense ones even at 87% sparsity. Existing designs either merge kernel rows through RMW or reduce bank conflicts with extra hardware, without eliminating them. SkipLane makes the entire accumulation path write-once. Each kernel row is processed in its own lane, which holds partial sums in three registers and retires up to three finished columns per cycle into memory banks that cannot conflict. Lanes and input channels are summed only at readout, so no partial sum is ever read back. Multipliers left idle by zero weights compute a second filter in the same pass. In RTL simulation, the engine stays within 0.5% of its frontend bound up to 70% sparsity and is 1.10-1.26$\times$ faster than an SCNN-style scatter accumulator with 18 banks and ideal RMW at 50-80% sparsity. Six engines meet 140 MHz on a PYNQ-Z2 using 21.1k LUTs and run LeNet-5 bit-exact on the board. For conv1, the engine needs 1.94$\times$ fewer cycles than a dense engine (1.26$\times$ faster end to end); for conv2, whose rows are only 13 pixels wide, it reaches 0.87$\times$ the dense speed.
Recent advances in large language models (LLMs) and autonomous agents are creating new opportunities for hardware design optimization. This paper examines three connected directions toward autonomous RTL and synthesis optimization: (1) Realistic benchmarking. We discuss reference-based and open-ended RTL optimization benchmarks that evaluate optimization opportunities under realistic EDA workflows. (2) Tool-grounded RTL optimization. We present Dr. RTL, a multi-agent framework that automates critical-path analysis, RTL rewriting, and implementation-level evaluation, while continuously improving through reusable optimization skills. Evaluated on 20 real-world RTL designs, Dr.~RTL achieves average WNS/TNS improvements of 21\%/17\% with a 6\% area reduction over commercial synthesis. (3) Design-specific synthesis optimization. We explore agent-driven synthesis script tuning and the discovery of executable synthesis algorithms across intermediate representations, technology-independent optimization, and technology mapping. Finally, we envision AI-native design automation that jointly explores architectural, RTL, and EDA algorithm design spaces, guided by verification constraints and implementation feedback.
As AI agents become increasingly capable of generating and optimizing hardware circuits, ensuring the correctness of AI-generated designs becomes more important. Meanwhile, advances in AI lower the barriers to developing and applying formal methods, creating new opportunities to automate and improve hardware verification. This invited paper presents an overview of the methodologies and applications of hardware formal methods in the AI era. First, we examine how agentic AI advances hardware formal methods across three levels: specification, proof construction, and reasoning engines. Second, we discuss how formal methods support reliable AI-driven hardware development through RTL generation, debugging, and correctness-preserving optimization. We review representative research alongside our recent contributions, highlighting key technical advances and insights from experimental results. Finally, we discuss future research opportunities toward proof-native hardware development, where formal reasoning could become an integral part of autonomous hardware design.
Fault-tolerant quantum computation requires decoders that combine accuracy, throughput, low latency, and scalability to large numbers of physical qubits. In photonic fusion-based architectures, erasures from photon loss and probabilistic fusion measurements are a dominant error mechanism, motivating decoders that remain accurate at high erasure rates. We introduce PRISM, a transformer-based machine-learning decoder designed to exploit the known locations of erasures in protocols subject to both Pauli and erasure errors. We benchmark PRISM across a wide range of fault-tolerant protocols based on surface codes, color codes, and quantum low-density parity-check codes, with distances up to 24. Across these benchmarks, PRISM matches the logical error rates of integer-programming-based decoders while being significantly faster, including at error rates up to 50% of threshold. We further optimize the decoder and its real-time hardware implementation to reduce latency while maintaining accuracy. Our optimized implementation on an AMD VP1902 FPGA can decode logical blocks of distance 8 in both space and time, demonstrating a latency of 6.59 microseconds and an amortized decoding time of 1.56 microseconds per logical block is possible. These results show that machine-learning decoding can provide accurate, low-latency inference for erasure-dominated fault-tolerant quantum architectures.
Post-placement timing and power co-optimization is critical to meeting setup timing targets and reducing power within placement constraints. A cell replacement can improve timing along one path while increasing power or reducing slack on others. Conventional optimizers follow fixed rules for scheduling and accepting repairs, limiting their ability to address design-specific bottlenecks. A large language model (LLM) can propose changes to these rules, but on its own it cannot reliably estimate how a cell replacement affects endpoint slack and power. TAPCO-G combines LLM-guided optimizer adaptation with graph-based physical priors to evaluate candidate cell replacements. The outer loop tunes tool settings using physical-design feedback and revises executable repair policies when tuning stalls. The inner loop anchors delay estimates to static timing analysis snapshots, accounts for upstream driver-load changes, and propagates delay shifts to timing endpoints. It combines these estimates with coarse-to-fine power screening to prioritize candidates for physical trials. TAPCO-G produced placement-legal, logic-equivalent implementations and outscored CERBERUS on all eight ASAP7 benchmarks from the MLCAD 2026 Contest, with a mean quality score gain of 5.516 points, and scored 21.648 points higher than TAPCO on average. These results demonstrate the effectiveness of the proposed co-optimization framework.
Designing a prescribed wave field in a heterogeneous medium requires an initial pressure distribution that compensates for the medium's propagation response. Repeated numerical inversion solves this task afresh for each target and environment. We introduce JAX-WAVE for amortized inverse wave design: a shared neural network maps desired terminal fields and known wave-speed maps directly to bounded initial pressures. Training through a differentiable finite-difference time-domain solver uses the physical design objective without requiring optimized control labels. Linear propagation and symmetric pressure bounds imply an exact sign-reversal relation for the regularized optimum. A shared-weight projection enforces this relation, preserves feasibility, and satisfies an exact identity for the paired-sign objective. We characterize the discrete propagator and its weighted adjoint to connect learning, numerical inversion, and optimality assessment. On an independent confirmation set, three trained models achieve unseen-material errors of 25.24% for geometric targets and 4.77% for reachable targets. Matched-capacity comparisons show improved reconstruction with the sign parameterization. Within a 5 ms median online budget, the learned map reduces mean error by 45% relative to accelerated numerical inversion on the heterogeneous benchmark; longer numerical solves recover greater accuracy. The results establish a reusable inverse-design procedure and show how its accuracy and computational value depend on target structure and query workload.
Large language model (LLM) inference during autoregressive decoding is fundamentally memory-bandwidth-bound. Existing three-dimensional (3D) stacked processing-in-memory (PIM) architectures alleviate the off-chip bandwidth wall, yet remain constrained by several limitations: physical layer (PHY), controllers, and direct memory access (DMA) engines compete with arithmetic units for advanced-node base-die area; hybrid-bonding keep-out zones fragment the base-die floorplan and impede physical design; compute tiles built in a dynamic random access memory (DRAM) process are restricted to low logic density, capping achievable throughput; and nonlinear operations offloaded to the host reintroduce a communication bottleneck. We present Tri-Stack-PIM, a heterogeneous three-die architecture that resolves these tensions by dedicating a top DRAM die to storage, a middle buffer die on a mature process node to PHYs, DMA engines, and near-memory compute units, and a bottom base die on an advanced node exclusively to single-instruction-multiple-data (SIMD) multiply-accumulate (MAC) arrays. We further introduce a Unified Buffer-Aware Ready-based (UBAR) hardware out-of-order micro-operation scheduler that enforces cross-die dependency correctness at runtime while maximizing issue-slot utilization through a multi-term priority function, recovering up to 90% of the cycles that an in-order policy would forfeit. A joint architecture-dataflow co-exploration identifies Pareto-optimal configurations that reduce the energy-delay product (EDP) by 33-66x over naive parameter selection. Evaluated across multi-head, grouped-query, and multi-query attention (MHA, GQA, MQA) mechanisms with batch sizes 1-32, Tri-Stack-PIM achieves geometric-mean speedups of 4.95x, 2.57x, and 1.68x across all three attention mechanisms and batch sizes over a graphics processing unit (GPU) baseline, AttAcc, and H2-LLM, respectively.
Rapidly evolving LLM architectures and heterogeneous mobile hardware make supporting new models in on-device inference engines a recurring and costly system challenge. Each model may require coordinated changes across conversion, graph construction, operators, and hardware backends. Existing coding agents often miss these cross-layer dependencies and struggle to diagnose failures across host--device execution paths. We present EngineAgent, an agentic system for automating on-device LLM model enablement. Its key insight is to separate reusable engine and hardware knowledge from model-specific implementation. Before enablement, EngineAgent constructs a hierarchy-aware engine index that captures engine abstraction layers and cross-layer dependencies, and pre-validates backend-specific build, execution, and debugging workflows using already supported models. For each new model, a builder uses this knowledge to coordinate cross-layer changes, while an auditor checks implementation completeness and drives iterative debugging through device-side validation. Across 12 tasks spanning three mobile LLMs and four engine--backend pairs on CPUs, GPUs, and NPUs, EngineAgent achieves 75% end-to-end success with either of two underlying LLMs, versus 33.3% for the strongest coding-agent baseline. Success requires compilation, on-device execution, and output-logit agreement with reference implementations. EngineAgent also reduces average per-task time and model-API cost relative to baselines using the same underlying LLMs.
Evaluating candidate parallelization strategies through distributed training runs makes strategy selection prohibitively expensive at scale. Performance simulation offers a lower cost alternative, yet controlled comparisons among existing simulators remain difficult because they differ in the training stages they model and the workloads on which they are evaluated. We introduce LM-SimBench, a unified framework, profiling dataset, and benchmark for evaluating LLM training simulators. The framework decomposes simulation into functional stages from model compilation to schedule level aggregation, connecting execution representations and cost estimators to measurable evaluation targets. Following this framework, we profile 23 model settings from 10 dense and Mixture-of-Experts (MoE) LLM families on an Ascend Neural Processing Unit (NPU) cluster. The resulting dataset contains 348 feasible configurations that jointly vary five parallelism dimensions and activation recomputation, with six views spanning configuration, rank, operator, event, and kernel granularity. Evaluations of representative training simulators demonstrate how LM-SimBench supports comparisons of prediction accuracy, assessment of configuration selection, and diagnosis of prediction errors. Matched GPU-NPU experiments validate the cross-platform applicability of the collection and evaluation protocol and demonstrate NPU-guided GPU configuration selection.
Edge NPU performance depends not only on hardware capabilities, but also on model transformation and the overall deployment pipeline. We propose a benchmarking methodology that separates these effects by comparing three configurations: Baseline, Vendor Guided NPU Only (VG-NPU), and Vendor Guided End-to-End (VG-E2E), where VG-NPU preserves common model I/O and host-side processing while VG-E2E follows the vendor-native deployment pipeline. We apply this methodology to four edge NPUs and three vision workloads. VG-NPU improves both accuracy and Runtime-call latency in 10 of 12 NPU--workload combinations, whereas VG-E2E reduces System-level latency in all combinations but improves accuracy in only four. Moreover, NPU-level performance rankings do not always match End-to-End rankings, and VG-E2E provides an additional 10.4--70.7\% reduction in System-level latency over VG-NPU. These results demonstrate the importance of evaluating vendor-guided optimization separately at the controlled model-transformation and full deployment levels when comparing heterogeneous commercial Edge NPU platforms in practice.
Branch-and-Bound (B&B) and $A^*$ are popular exact search methods originating from Operations Research and Artificial Intelligence, respectively. Although the two methods share fundamental search principles, their different ways of exploring the search space can lead to substantially different computational performance. We investigate these differences using the Resource-Constrained Project Scheduling Problem (RCPSP) as an exemplary problem setting. We first establish the relationships between mixed-integer linear programming, state-action, and timed Petri-net representations. Since B&B and $A^*$ admit numerous algorithmic enhancements, we focus on relatively basic implementations. This allows us to examine the fundamental differences between the methods rather than compare the performance of state-of-the-art solvers. By using the same lower bound and best-first node selection, we isolate the effects of the search mechanisms, particularly the identification of equivalent states reached through different scheduling decision sequences. Experiments on 480 benchmark RCPSP instances show that graph-based $A^*$ substantially outperforms the B&B variants considered. With additional pruning rules, $A^*$ proves optimality for all 480 instances, compared with 445 for best-first B&B under the same time and memory limits. Depth-first B&B uses less memory and can find feasible solutions even when the search does not finish within the time limit. Stronger linear programming relaxations reduce the search space but introduce considerable computational overhead. Our findings highlight the importance of duplicate-state detection and clarify the computational trade-offs between the search approaches. These insights can help researchers select an appropriate method and identify opportunities to incorporate effective mechanisms from one approach into the other.
Local decoding usually fixes one weight precision for the whole generation. We study a different allocation: store 8-bit weights, decode with their top 4 bits, and redo a step at 8 bits only when the low-precision output distribution looks uncertain (entropy above a threshold or a small top-two margin). Quantization is simulated, the model is Qwen3-0.6B, and the benchmark is GSM8K. Cost is counted in weight bytes read per token. On 36724 replayed steps the entropy of the low pass ranks argmax flips with AUC 0.93. At a 15% escalation budget it catches 78% of flips and the margin gate 94%, against the 15% expected for a random gate of equal rate (a computed expectation, not a run). In 150 live problems all-high scores 64.0% and all-low 55.3% (McNemar p=0.053). An entropy gate with a 16% escalation rate scores 62.7% at 0.87 of the all-high weight bytes. Its paired difference is -1.3 (-8.0 to +5.3) points to all-high and +7.3 (+0.0 to +14.7) points to all-low (p=0.080), so the live data do not separate the gate from either end. Verified speculation reaches zero KL at similar bytes in the same cost model. A live random control, a thinking-mode phase rule, a second model and live KL were not run.
Local language models can save memory by storing weights in fewer bits, and they can reduce sensitivity to the order of answer options by averaging a few reorderings. We ask whether the first makes the second worse, and which is the cheaper way to spend a fixed budget. On Qwen3-0.6B and Qwen3-1.7B with simulated round-to-nearest weight quantization (8, 6, 4 and 3 bits, fp16 reference), read from the logits of the letters A to D on ARC-Easy, ARC-Challenge, MMLU and HellaSwag (300 items each), 6 bits lose no accuracy against fp16 (they score +1.8 (+1.0 to +2.5) and +0.9 (+0.3 to +1.5) points higher, which we do not explain), and 8 bits change it by -0.7 (-1.1 to -0.3) and -0.4 (-0.7 to -0.2) points. At 4 bits the answer-slot skew rises from 0.15 to 0.53 (0.6B) and from 0.07 to 0.12 (1.7B); Gaussian noise at the same weight SNR gives 0.15 and 0.37 (two draws) and 0.19 (one draw), so the control is inconclusive on whether rounding adds slot skew beyond equal-power noise. Flip rates rise but stay below an accuracy-matched baseline of independent uniform errors. Averaging four cyclic orders recovers +12.6 points at 4 bits for 0.6B (+5.3 at fp16). We price bits and passes in one machine-independent unit, weight bytes read times passes. In cost-matched pairs, extra orders beat extra bits only when the weights have 6 or more bits, and the decision table reduces to: use 6-bit weights and spend the rest of the budget on up to four orders, one pass each. Everything is simulated on two small models with the simplest quantizer; a title-level search found no earlier study of quantization together with option order.
Deploying vision transformer models across connected and automated vehicles (CAVs) requires joint management of computation and Vehicle-to-Vehicle (V2V) communication. Static split-inference methods use fixed partition points and cannot adapt to time-varying link bandwidth, processing load, and concurrent multi-stream traffic. This paper proposes an edge orchestration framework that jointly selects model partition points, per-layer quantization bitwidths, and execution placement across heterogeneous vehicular compute nodes. The joint partitioning and mixed-precision allocation problem is formulated as a Mixed-Integer Linear Program (MILP) that minimizes compute and communication energy subject to end-to-end latency and task-quality constraints. The framework is evaluated on Jetson Orin Nano (8~GB), Jetson Orin NX (16~GB), and Jetson AGX Orin (32~GB) nodes using OPV2V-driven multi-stream workloads with $K \in \{2,4,6,8\}$. Across the evaluated configurations, the proposed formulation reduces V2V communication energy by $33.3$--$36.0\%$ relative to a Uniform INT8 split. At $K=8$, end-to-end task completion latency is reduced by $34.0\%$ on the Orin Nano and $33.1\%$ on the Orin NX relative to the same baseline, while limiting the reduction in 3D detection accuracy to $3.1$--$4.1$ percentage points in $\mathrm{mAP}_{50}$ relative to FP16 execution.
We present Sable, an argument system and single-GPU prover for the statement that a committed, integer-quantized transformer produced a given token sequence from a given prompt, bit for bit. Sable fixes an integer function F_O with no floating-point step, in which every rounding, normalization, softmax and sampling decision is determined by its inputs, and proves it with a constraint system whose relations provably never wrap modulo the 31-bit KoalaBear prime. The proof batches zerochecks and LogUp-GKR lookups into one sumcheck per domain, and commits to every witness tensor and weight in one multilinear commitment built from Reed-Solomon codes, BLAKE3 Merkle trees and a mixed-length BaseFold opening. The prover streams the model layer by layer on one GPU. On one NVIDIA RTX PRO 6000 Blackwell GPU, Sable proves all 64 layers of Qwen2.5-32B in 92.5 s for 4,096 tokens and 398 s for 16,384 tokens, and covers Qwen3-32B and the mixture-of-experts Qwen3-30B-A3B (4,096 tokens in 121.8 and 84.7 s). A proof costs 41 to 50 times the serving time, or 6.4 cents per 4,096-token request at public GPU prices, and 40 to 64 times less time per parameter and token than zkLLM. On WikiText-2, F_O's greedy token matches the BF16 model's at 86.3% of positions; on Qwen3, F_O is within 1.6 points of BF16 on MMLU and 1.7 points on GSM8K. A verifier with a compiled core checks a proof on one CPU core in 19 to 56 s. In the random-oracle model, the interactive proof has round-by-round soundness error 2^-103. The proof is not zero-knowledge, so the system targets open-weight models. Code: https://github.com/moonmath-ai/Sable
Structural causal bandits use causal knowledge to guide exploration when reward mechanisms are unknown. This paper extends the approach to partially known causal structure, information from other environments, and realizable counterfactual actions. First, we develop graphical criteria for minimal intervention sets under Markov equivalence and characterize possibly-optimal minimal intervention sets for maximal ancestral graphs. A search algorithm finds sets that are possibly optimal in at least one graph represented by a partial ancestral graph. Second, we derive target reward bounds from source distributions through partial transportability, accounting for non-manipulable variables. Dominance relations provide further bounds for action pruning and restricted exploration, with a regret guarantee under valid prior bounds. Third, we formulate counterfactual structural causal bandits over actions supported by specified experimental capabilities. Graphical characterizations of minimality and possible optimality yield algorithms that remove equivalent or dominated choices while preserving an optimal action. Experiments with specified structural causal models examine how these reductions and transferred bounds affect learning. Together, these results clarify how causal knowledge and experimental capabilities determine which actions merit exploration and guide learning within the retained action space.
In Mixture-of-Experts (MoE) models, the nature of expert specialization remains controversial. Reports of domain-associated expert preferences contrast with analyses attributing routing primarily to token identity or syntactic patterns. To clarify these differing accounts, we look beyond expert-level routing to investigate the neuron-level organization of domain-specialized computation using Routing-Aware Magnitude Profiling (RAMP), a measure developed for this analysis. Using mixed-domain calibration data, we identify domain-specialized neuron sets with 58-74% overlap across multi-source samples of the same domain, compared with 15-24% across domains. To understand how this organization evolves during training, we trace neuron importance throughout pre-training and post-training across three fully open MoE families. Neuron importance continues to reorganize between pre-training checkpoints despite comparatively stable expert-level importance rankings, while post-training largely preserves neuron rankings. Building on these neuron-level perspectives, we further introduce RAMP-based Pruning (RAMPr) to select neurons across experts for balanced multi-domain capability preservation. At 75% neuron retention, RAMPr preserves average 91-98% of original full performance across six models. At 50% retention, our pruning method can reduce resident GPU memory by 36-43% and improves batched prefill throughput by 17-39% effectively. Our code is available at https://github.com/ydyjya/Neuron-Level-Specialization-in-MoE
Client-side automatic speech recognition (ASR) across Indic and Classical scripts eliminates cloud transcription costs, network tail latency, and server-side audio retention, yet neural exports face four systems bottlenecks in browsers and mobile runtimes: (1) monolithic per-language Conformer checkpoints require ~177 MiB per script (> 2.1 GiB across 12 scripts), exhausting CacheStorage quotas; (2) static relative positional encoding tables embed 10.2-20.5 MB of FP32 constants while 1x1 Conv1d layers trigger slow or unsupported ConvInteger kernels in WebAssembly SIMD; (3) sliding-window CTC flickers on boundary tokens; and (4) mobile WebAudio pipelines suffer 44.1/48 kHz sample-rate mismatches and silent AudioWorklet stalls under iOS WKWebView. We present Swanada, an open-source 16 kHz streaming ASR system spanning Classical Sanskrit, Indian English, and ten Indian languages (sa, en, hi, kn, mr, bn, ta, te, ml, gu, pa, or) across browser WebAssembly, Node.js, and Python. Swanada pairs capability-routed shared INT8 Conformer encoders (a 17-layer 177.38 MiB Studio tier at $d = 512$ for desktop/servers and a distilled 14-layer 25.35 MiB Mobile tier at $d = 256$ for phones) with twelve hot-swappable 515.0 KiB native-script linear CTC heads ($257 \times 512$), cutting 12-language storage by $11.6\times$ (183.4 MiB) and $67.8\times$ (31.39 MiB; 25.85 MiB first load). Runtime protobuf tail surgery exposes the shared representation in $< 2$ ms, while dynamic positional synthesis, MatMul pointwise convolutions, and post-quantization QInt8 head calibration preserve sub-30 MB accuracy. Across $N = 480$ held-out and $N = 1,280$ open public test clips (FLEURS, LibriSpeech, GLOBE, AMI, wild Sanskrit), Swanada achieves 5.43% held-out and 8.87% 12-language open CER on Studio (18.56% and 19.23% on Mobile) at $0.0097\times$-$0.0264\times$ RTF, with 30.6 ms median TTFT and 0.00% committed-prefix churn.
Optimized floating-point inference is not reproducible across environments: the same model on different hardware, compilers or thread counts can produce different bits. We present tritify, an open-source runtime that executes the forward pass of real models -- decoder-only language models, Mixture-of-Experts decoders, and the Segment Anything 2.1 image/video stack -- with the entire run-time path in exact integer arithmetic; floating point is confined to offline quantization and the float reference used for verification. We make three separate claims and verify each. (1) Cross-hardware reproducibility: the integer path produces bit-identical output run to run, across CPU instruction-set architectures, and across CPU/GPU, carried by a reproducing SHA-256 of the output. (2) Decision fidelity: the integer path reproduces the float reference's decision on the models and inputs tested, with the numeric exceptions measured; per-layer fidelity through sixteen layers of OLMoE-1B-7B and of a 106-billion-parameter MoE shows no fidelity cliff. (3) Location independence: a model's computation can be split across instruction sets, CPU and GPU, and networked machines with zero effect on the output bits. GLM-4.5-Air (106,852,251,264 parameters, 427 GB of integer codes) generated its answer across three machines, none of which can hold its integer codes in RAM, bit-identically to a single-host reference. The consequence is verifiable distributed inference: an untrusted server or a fleet of devices runs the model while an open scalar oracle re-derives the exact bytes; a guarantee against a dishonest server is future work. We do not claim a per-device speed-up, bit-equality of floating-valued intermediates, or confidentiality. Code: https://github.com/pelloran-inc/tritify
Existing sequential user modeling methods mainly focus on improving the backbone encoder or learning task-specific user representations for a single prediction objective. We instead study how to export the multi-layer user states of a frozen long-history backbone as compact, timestamp-addressable representations for downstream training backfill and serving. In this setting, the user state at a given timestamp summarizes the user's actions before that time, so downstream systems need only the state aligned to each target timestamp rather than the full hidden-state timeline. To this end, we present \texttt{SeqFold}, a compressed-state interface that combines learned multi-channel fusion, channel-specific temporal decay, and Lookup-Free Quantization (LFQ) to produce compact discrete codes from frozen backbone states. Task-specific decoders then map these shared codes into flexible embedding spaces for downstream models. To make timestamp-addressable export practical at scale, we further develop a fused streaming implementation that updates the fusion recurrence after every action while materializing states only at target timestamps. On large-scale proprietary datasets, SeqFold reduces per-state representation storage by $3{,}400\times$ while preserving most of the downstream ranking performance of the uncompressed model, showing that SeqFold is an effective interface for reusing long-history sequence backbones in downstream models.
Grid mismatch in wideband channel estimation leaves structured cancellation residuals after strong-path subtraction. These residuals generate spurious correlation peaks or mask weak arrivals, turning continuous parameter errors into path-count errors. We propose RC-SAGE-Brent, a residual-closed-loop estimator that jointly refines continuous delay-scale parameters and corrects the unknown-order path set. Within each feedback cycle, ambiguity-constrained alternating Brent searches suppress strong-path cancellation residuals. Candidate validation, resolution-constrained pruning, and full-domain residual redetection then revise the active path set. For linear frequency modulation (LFM) probes, an observable signal-to-residual ratio adaptively scales the model-order penalty to mitigate overestimation caused by delay-scale coupling. Theoretical analysis links off-grid parameter errors to local cancellation-residual curvature and weak-path detectability. Factorial ablations, paired comparisons against standard sparse and off-grid estimators, and measured channel replay demonstrate improved path-set recovery and waveform reconstruction while delineating the operational boundaries of the method.
We present FAME-QP, a GPU-accelerated solver for dense quadratic programs arising in linear model predictive control. FAME-QP combines constraint-dependent operator representations with fused single- and two-kernel iterations replayed through CUDA graphs, automatically selecting the execution configuration through device calibration and problem-specific timing. It probes a cached operator bank to select the initial penalty and updates operators lazily when problem matrices change. Numerical benchmarks and simulated humanoid and quadrotor control experiments demonstrate reduced latency relative to competing GPU solvers while maintaining solution accuracy and control performance.
DeepSeek-V4.1's 203 GB of Engram n-gram tables sit in host DRAM today, taking 190 of the 223 GiB a 4-GPU serving process uses. Row indices depend only on input tokens, so reads can start with each step and overlap earlier layers. V4.1's two Engram layers have windows that differ by 30x (0.3 vs. 9.3 ms). We show that this deadline, together with session reuse and contention on a shared device, decides which tier each table can use and which layers need cache, and we give a model that predicts the resulting slowdown from measured read times. Agent and chat traffic reuse rows within sessions, and static hot sets transfer poorly. We build SlackTier, a table tier for SGLang that issues all lookups at step start. It reads the short-window layer first and splits a small GPU row cache across layers. The path runs inside the decode CUDA graph and is bit-exact with the original gather. Layer 14's table can go to NVMe uncached with no measurable decode cost. With both tables on four NVMe disks, mean time per output token on agent and chat replays rises at most 1.4% over unmodified SGLang, and host memory falls from 212 to 34 GiB. Both tables need no cache when read over RDMA (remote direct memory access) from another node's memory; one copy serves two instances. On a KV-constrained agent workload, using the freed memory as host KV cache at the same memory budget raises median throughput by 36% and cuts median p90 time to first token from 38 to 24 s.
With the rise of neuromorphic technologies, simple and tunable neuron models are needed to analyse and design spiking systems. However, the simplest neuron models, e.g., Leaky Integrate-and-Fire (LIF) models, usually fail to capture the excitable behaviours of biological neurons. This could be a significant limitation, as excitability enables reliable spike timing under parametric uncertainties. Recently, a minimal excitable model, the so-called High-Pass Model (HPM), was introduced in neuroengineering. It simply consists of a static sigmoid with a high-pass filter in positive feedback. Given its novelty, it is still unclear how easily the HPM can be tuned, and how much of the excitable behaviours of a biophysical neuron it can reproduce. To address these questions, we investigate the tunability of a first-order HPM sub- and supra-rheobase, i.e., below and above the onset of the tonic spiking regime (where the neuron spikes periodically), and compare its behaviours with those of a simple Hodgkin-Huxley-type Conductance-Based Model (CBM). Below rheobase, both models fire spikes in response to transient inputs, including post-inhibitory rebound spikes. Above rheobase, an affine reparametrization of the input of the HPM suffices to fit its frequency-current curve to that of a CBM. The two models mostly differ near their respective rheobases, where the first-order HPM lacks bistability and spike latency. We suggest that modifying the frequency-selective element of the HPM may be sufficient to overcome this limitation. These results highlight the potential of the HPM as a fundamental computational primitive in neuromorphic, spike-based technologies.
Tensor wheel decomposition captures complex correlations in high-dimensional data through interactions between outer-ring factors and a high-order central core. However, updating these components requires the explicit construction and manipulation of large-scale matrices, which limits computational efficiency and incurs particularly high computational and memory costs for the central-core update. To address these limitations, we propose dual-core tensor wheel decomposition (DCTW), which factorizes the central core into two lower-order cores linked by a shared latent bond. Each core is coupled to a different group of outer-ring factors. We further propose a structure-cached acceleration strategy that avoids explicit large-scale matrix multi- plications and caches intermediate tensors generated during tensor network contractions for reuse across block updates. This reuse reduces redundant computation and avoids the explicit construction of large matrices. Complexity analysis and experiments show that the strategy based on structural caching accelerates optimization compared with explicit and implicit up- date schemes while limiting the increase in peak memory as the ranks grow. Experiments on color video completion and robust denoising show that DCTW matches or outperforms representative tensor network methods in reconstruction quality, computational efficiency, and scalability.
One of the major sources of inspiration for neuromorphic engineering is the central nervous system, which is orders of magnitude more efficient than classical digital clock-based computers. Neuromorphic control aims at recreating this efficiency in control systems, combined with (formal) stability and performance guarantees. In our previous work [1], we have established formal guarantees for the emulation of static output feedback controllers implemented using integrate-and-fire neurons. In this paper, we investigate the ``efficiency'' of the resulting controllers in terms of sparse spiking activity. By changing the network structure of our original implementation, foregoing the unit gain assumption made in our previous work, we will establish that the chosen architecture of the spiking controller significantly affects its sparsity and discuss the implications of these observations for the efficient implementation of spiking controllers.
This article investigates the existence and stability of periodic behavior arising in the feedback interconnection of neuromorphic systems, which evolve according to continuous dynamics but interact only through discrete events. Exploiting the event-driven nature of this interaction, each system is modeled by an operator that maps the history of events to the delay of its response. Building on the fading-memory properties of these operators, the article develops a small-gain result establishing the existence, uniqueness, and robustness of periodic one-to-one rhythms.
Neuromodulation, the modulation of excitability through the regulation of neuronal parameters, is a key tool in neuromorphic control design. This paper investigates how spiking excitability can be modulated by intrinsic noise. Focusing on a simplified memristive neuron model, we show that intrinsic noise plays distinct functional roles depending on the feedback pathways: Intrinsic noise in the fast excitatory feedback shapes the nature of excitability and modulates the sensitivity of the neuron to external/internal stimuli, whereas that in the slow inhibitory feedback provides internal stimuli that can trigger stochastic spiking. We expect these findings to guide the design of neuromorphic systems that harness intrinsic noise to exploit beneficial stochastic phenomena, such as stochastic resonance.
Electronic design automation (EDA) workflows remain highly fragmented, requiring engineers to coordinate heterogeneous representations, specialised software tools, and iterative verification across multiple design stages. Although large language models have brought more general reasoning and code-generation capabilities to EDA, many existing approaches remain focused on isolated tasks and struggle to plan, verify, and repair designs autonomously within executable engineering environments. Here we introduce ChipOmni, a knowledge-enhanced, context-evolving AI agent framework for EDA. ChipOmni integrates multimodal understanding, dynamic planning, multi-agent collaboration, and verification-driven tool interaction into a unified autonomous system. By continually incorporating feedback from external engineering tools, the framework maintains an evolving task context, integrates domain knowledge, and iteratively refines intermediate designs. Across benchmarks for analog circuit, RTL, testbench, and formal-assertion generation, ChipOmni improves multiple task-specific measures over the evaluated baselines and solves all 30 AnalogCoder-Pro tasks. In a long-horizon case study, ChipOmni advances a natural-language RISC-V specification through three design levels to a micro-SoC GDSII layout that passes physical sign-off, without human intervention after initialization. Together, these results show that ChipOmni can coordinate verification-driven design across heterogeneous tasks and sustain long-horizon engineering workflows, advancing a shift from fragmented, tool-centred processes towards agent-centred, closed-loop systems.
Multiple-criteria decision aiding (MCDA) proposes models and methods for different types of decision problems such as choice, ranking or sorting. Such models involve various parameters that must be elicited. In the elicitation process, all necessary information has to be taken from the decision-maker. For this, several direct and indirect elicitation methods are suggested in the literature. In this work, we concentrate on direct elicitation: we aim at providing a rigorous elicitation procedure for the parameters of the Non-Compensatory Sorting model (NCS), which has been characterized by an axiomatic analysis. A basic version of the NCS model is considered, i.e., a model with two categories and no vetoes. The parameters are the set of sufficient coalitions of criteria and the profile separating the two categories. Regarding the sufficient coalitions, we propose several questioning algorithms that engraft questions on classical graph exploration algorithms such as depth-first search. Such algorithms are implemented and evaluated by simulation. For eliciting the limit profile, we design a questioning algorithm using dichotomy. Questioning algorithms can be optimal in the worst case or on average. An optimal algorithm in the worst case has been proposed by Hansel in the framework of monotone Boolean functions. We implement and evaluate this algorithm as a variant of the depth-first search approaches. Regarding optimal questioning strategies on average, we evaluate decision trees for up to four criteria. On the other hand, we assess how more general is NCS as compared to MR-Sort, a particular case of the NCS model in which sufficient coalitions can be represented by additive weights.
The author describes an open implementation flow, from HDL to a programmable bitstream, for the Xilinx Spartan-3E (XC3S100E to XC3S1200E) and Spartan-6 (XC6SLX16, XC6SLX45), devices that only the discontinued ISE 14.7 supports. The flow runs unchanged in a web browser or in Node.js: Yosys and nextpnr compiled to WebAssembly, with nextpnr's Himbaechel framework given Spartan-3E and Spartan-6 architectures generated from Silinx's own device descriptions, bit database and timing model, and Silinx's own bitstream writer. The bit database was built by black-box observation of ISE's documented XDL and bitgen tools, using codeword-batched experiments; the router is given only switches whose bits were measured, and the writer refuses a feature it has not measured. ISE is the oracle: for the same placed and routed design, the bitstream is byte-identical to the one bitgen writes and ISE's DRC is clean. Placement and routing were first done by an in-house annealer and PathFinder router, which nextpnr replaced once it matched them. On 67 open-source designs for the XC3S1200E, compared with ISE at the same optimisation goal (45 designs built by both), the flow uses 15% fewer slices and has 14% shorter critical paths at goal Area, 21% fewer slices and 8% shorter paths at Speed, and 20% fewer slices but 12% longer paths at Fast (geometric means). XST cannot read 15 of the designs. The flow is published as the npm package silinx-fpga (Apache-2.0).
Multi-objective evolutionary optimization increasingly involves large populations, expensive problem evaluations, and diverse algorithmic structures. These workloads expose the limited parallelism of loop-based implementations, while rewrites for accelerator execution can alter selection order, tie handling, and population updates. AscendMOEA is presented as a scalable platform that executes multi-objective evolutionary algorithms (MOEAs) on Huawei Ascend neural processing units (NPUs) and conventional central processing units (CPUs). The platform represents the decision vectors, objectives, constraints, and auxiliary states as tensors and provides reusable interfaces for algorithms, problems, population operators, quality indicators, monitoring, and repeated experiments. Dense computations are executed in batches, such as dominance, distance, variation, and problem-evaluation calculations. Short recurrences with causal dependencies retain their prescribed order and consume precomputed tensor results, which preserves the behavior of the original algorithms. AscendMOEA contains 18 algorithms, 155 benchmark and application problems, 19 public operator interfaces, and 11 quality indicators. Experiments on eight Ascend NPUs and 192 physical CPU cores evaluate operator throughput, end-to-end runtime, memory consumption, numerical agreement, and implementation ablation. Tensorized operators obtain a median acceleration of 1.58 times on the NPU. At large population scales, complete algorithms achieve a median acceleration of 5.76 times while retaining the recorded quality indicators. Moreover, the results identify the workload scale and ordered computation that determine whether accelerator execution is beneficial. AscendMOEA is open-sourced at https://github.com/dqlme/AscendMOEA.
Neural processing units (NPUs) provide high compute density and energy efficiency through specialized matrix engines and software-managed on-chip memory. However, their libraries primarily target dense computation. Sparse matrix-dense matrix multiplication (SpMM), a key kernel in graph analytics, sparse neural networks, and scientific computing, requires index-driven operand selection, indirect addressing, scattered memory accesses, and load balancing. These requirements conflict with the fixed shapes and contiguous layouts preferred by NPU matrix engines. GPU Tensor Core SpMM methods cannot be directly transferred to NPUs with decoupled vector and matrix engines. We present AscSpMM, which separates irregular operand preparation from regular matrix computation through a parameterized Vector-CSR representation. The vector engine decodes indices and gathers and reorganizes dense operands, while the Cube engine performs matrix multiply-accumulate operations. A double-slot ring buffer enables dependency-aware asynchronous pipelining, while operand reuse and runtime-adaptive tiling reduce cross-engine stalls. On an Ascend 910B3, AscSpMM achieves geometric-mean speedups of 2.36x over GEMM, 19.92x over an existing SpMM implementation, and 5.82x over cuSPARSE on an A100. It reduces matrix-input storage and peak HBM footprint by 48.24% and 22.98% on average, while remaining competitive with specialized GPU Tensor Core SpMM kernels. The code is available at https://github.com/LfLab-AI/Ascend-NPU-SpMM.
We present GigaEdge Spench, an open-source SDK for streaming speech enhancement on CPU servers, mobile devices, and in browsers. Applications can build enhancement channels from neural denoising, normalization and dynamics blocks, sample-rate conversion, and acoustic echo cancellation where supported. These stages can be combined, while normalization can also run without a neural model. The release includes an 8 kHz INT8 denoiser and discriminative and hybrid 48 kHz FP32 models. A shared C++ core supports ONNX Runtime and TensorFlow Lite through native interfaces, Android and iOS SDKs, and WebAssembly integration. Independent stream contexts share model resources, and consecutive frames from one stream can be processed in a single inference call. We evaluate the released models on EARS-WHAM v2 and compare their quality and processing costs with RNNoise and DPDFNet2. All tested native and Web configurations process files faster than real time, although larger chunks require more time to collect input. We also measure how many streams a shared model can process on a CPU. Our contribution is a configurable deployment system and an experimental study of how model choice, chunk size, and execution environment affect its use. All reported SDK timing uses ONNX Runtime. Index Terms: speech enhancement, streaming inference, cross-platform deployment, temporal frame grouping, computational efficiency
This paper explores a controller that is at the crossroads of neuromorphic, i.e., spike-based, and impulsive control systems. The controller consists of a single integrate-and-fire-like neuron that generates an input proportional to the system output when the neuron variable reaches a threshold. We prove that any static output-feedback stabilizable single-input single-output (SISO) linear time-invariant (LTI) plant can be made semi-globally asymptotically stable (sGAS) in closed loop with the proposed neuro-impulsive controller. This improves on existing fixed-amplitude neuromorphic controllers, which only achieve practical stability, but at the price of using graded spiking inputs. Moreover, we provide an algorithm for choosing appropriate controller parameters given a set of admissible initial conditions. A numerical example of an inverted pendulum linearized around its upright equilibrium illustrates the method.
Large language model (LLM) agents are being explored for circuit design, but their ability to produce high-quality custom layouts has not been extensively evaluated. ICLayout-Bench is a benchmark in which agents use electronic design automation (EDA) tools to construct and optimize GDSII layouts from transistor-level circuit netlists. These layouts are evaluated using physical verification, parasitic extraction, and post-layout simulation. Layouts that pass the physical and functional checks are scored on electrical performance and area. The benchmark includes 165 tasks across 13 process design kits (PDKs), covering technology nodes from 3 nm to 180 nm. The tasks span analog, mixed-signal, and digital circuits in open-source and commercial EDA flows. The experiments evaluate 22 configurations spanning seven models on 21 public and 19 private tasks. Mean layout scores range from 4.22 to 80.26 on public tasks and from 1.43 to 67.01 on private tasks, on a 100-point scale. Higher reasoning effort does not consistently improve mean scores, and configurations with comparable scores can incur substantially different model costs.
Vision-language-action (VLA) models enable robots to understand and execute complex instructions, but their autoregressive (AR) action generation introduces significant latency on resource-constrained robotic platforms. Speculative decoding can accelerate AR-based inference by parallelizing action generation and verification; however, existing approaches rely on costly draft models, which are inefficient on edge platforms. In this paper, we propose Zora, a hardware-software co-design framework for accelerating AR-based VLA inference. Specifically, Zora introduces a lightweight retrieval-augmented generation (RAG)-based draft model that exploits robotic dynamics without additional neural draft models. We further reduce batch verification overhead through a kinematics-guided action-acceptance strategy and a KV-cache-sharing attention mechanism. To address the retrieval overhead introduced by RAG-based drafting, we co-design dedicated hardware support, Zora core, to address the memory irregularity in RAG-based drafting. We evaluate Zora on four VLA models with the LIBERO benchmark. Zora retains comparable accuracy while achieving up to 3.4$\times$ speedup with software-only optimization and up to 7.6$\times$ speedup with hardware support over GPUs.
Modern dehazing networks are often computationally expensive and overfit to synthetic haze, limiting real-time deployment. This underscores an urgent demand for efficient, high-fidelity restoration methods that can operate on resource-constrained edge devices in practical, dynamic environments. We introduce PhysDNet, a lightweight multimodal architecture that fuses NIR imagery with sparse LiDAR depth and is trained with a physics-constrained dual-head objective. Differentiating through a fixed Koschmieder inversion induces density-adaptive gradient amplification, acting as an implicit resource allocation mechanism that concentrates learning on heavily degraded regions without increasing inference cost. PhysDNet delivers superior restoration with minimal capacity and enhanced training efficiency, facilitating real-time deployment on edge devices without increasing inference overhead. On the Seeing Through Fog benchmark, PhysDNet outperforms competitors by 1.67 dB at 5.2 times lower compute while recovering 54.9% of fog-induced detection loss. Ablations and cross-domain evaluations show that physics-guided training improves generalization, including under non-homogeneous haze that violates the Koschmieder assumption. PhysDNet further demonstrates compatibility with fixed-function NPUs, running at 29/45/99 FPS at <4 W across L/M/S variants. Code, deployment scripts and pre-trained checkpoints are available at https://github.com/Heatdh/PhysDnet.
Modern accelerators specialize recurring computation and replicate it across regular hardware structures to achieve high performance. Sustaining this parallelism requires equally deliberate data delivery. Yet design tools often express these structures as sequential programs or flatten them into separate hardware modules and connections. This obscures shared patterns and leads to repeated compiler work. We introduce Single Program, Multiple Connected Work Units (SPMW), a grid-based programming model for scalable accelerator design that makes grid regularity a first-class abstraction. SPMW decouples local work-unit behavior from grid connectivity and data delivery. To our knowledge, SPMW is the first programming model to retain regularity throughout the compilation process, combining behavioral HLS with structural RTL generation for both fixed-function and domain-specific instruction-programmable accelerators. We implement SPMW with a Python frontend and an MLIR-based compiler that synthesizes each distinct kernel configuration once for reuse across independent hardware instances. Preserving regularity also enables parallel compilation and functional simulation to accelerate iterative design feedback. We use SPMW to generate a 32x32 systolic array that reduces GEMM latency and parallel kernel-to-RTL compilation time by 4.36x and 619x relative to AutoSA. Our FFT achieves up to 2.65x lower latency than HP-FFT. Our mini-TPU and our SPMW implementation of the FEATHER accelerator demonstrate complex composition and outperform their RTL baselines. Parallel functional simulation provides up to 18.4x speedup over Vitis HLS C simulation on the mini-TPU workloads. SPMW is also agent-friendly: given the same design specification, all five coding agents produce SPMW designs that satisfy the correctness and latency requirements, with 7.51x lower token usage than for SystemVerilog.
Mechanistic interpretability (MI) enables monitoring and steering LLMs by operating on their internal state during inference. MI applications remain difficult to develop, expensive to execute, and challenging to manage at runtime. We present OrigaMI, a system that integrates MI applications as first-class components of LLM serving, enabling simplified development, efficient execution, and flexible deployment. Guided by a comprehensive analysis of modern MI applications, OrigaMI streamlines the MI applications development via a simple Python-based Domain Specific Language (DSL) for accessing intra- and inter-layer runtime model state at well-defined trigger points during inference. OrigaMI enables efficient access to ephemeral attention scores via a novel FlashInspect kernel that retains the performance benefits of FlashAttention. OrigaMI's compiler integrates multiple MI applications into the performance-optimized inference execution flow while ensuring conflict-free coexistence. OrigaMI's runtime supports dynamic, per-request activation and deactivation of MI applications without service interruption or performance degradation when inactive, leveraging OrigaMI's dynamic memory management and CUDA graph-compatible execution. We integrate OrigaMI with vLLM and evaluate ten MI applications, including sparse autoencoders, steering, and jailbreak detection, across four state-of-the-art LLMs. OrigaMI incurs negligible execution overhead, up to two orders of magnitude lower than existing frameworks, while enabling per-request activation and deactivation up to 1,000 times faster than alternatives. These results demonstrate that OrigaMI makes MI applications practical for deployment in production LLM serving systems.
This paper introduces a budget-aware, multi-objective framework (called PRISM) for RTL optimization that improves power, performance, and area (PPA) while sharply limiting expensive commercial synthesis tool calls. Starting from a synthesizable baseline and functional testbench, the method iterates through LLM-driven rewrite generation, fast compile/simulation equivalence filtering, low-cost proxy feature extraction, and selective commercial synthesis tool (Synopsys Design Compiler (DC)) evaluation. To prioritize which candidates deserve high-quality synthesis, we train a preference-based reward model using pairwise ranking supervision derived from commercial synthesis tool outcomes, and combine ensemble uncertainty with a diversity-aware acquisition rule to avoid early bias and redundant evaluations. A key advantage is that PRISM maintains a best-tradeoff set G of non-dominated designs throughout the run: G preserves the best solutions found so far, is fed back into generation and refinement, and enables consistent, cumulative improvements rather than repeatedly restarting from the baseline. Across RTLLM v2.0 modules, the approach consistently yields post-synthesis gains under fixed commercial synthesis tool call budgets, and ablations confirm that reward-guided selection and candidate dropping are central to sample-efficient progress. PRISM efficacy is evaluated across multiple technology nodes (7 nm, 15 nm, and 45 nm) using identical pipelines without retraining.
Este trabajo aborda la creciente necesidad de aumentar el rendimiento y las dificultades asociadas a la aceleración de aplicaciones de computación intensiva. Como alternativa a las arquitecturas convencionales, emergen las arquitecturas heterogéneas que incorporan aceleradores, como FPGAs. En este tipo de sistemas el particionamiento hardware/software y la complejidad de la programación representan una barrera para la adopción en aplicaciones reales. Con el objetivo de abordar esta problemática, se propone y valida un método sistemático, orientado a la aceleración de aplicaciones sobre arquitecturas heterogéneas basadas en FPGA, independiente del fabricante y dispositivo. El método se validó experimentalmente mediante casos de uso basados en librerías de alto nivel de Machine Learning, específicamente AI-Toolbox para Reinforcement Learning y LibSVM para Support Vector Machines, alcanzando aceleraciones globales de hasta 24x y 188.69x, respectivamente. El método propuesto reduce de manera significativa el esfuerzo de desarrollo y facilita la toma de decisiones tempranas durante el proceso de diseño de aceleradores. Asimismo, según el criterio del autor, este trabajo contiene los primeros aportes de aceleración basada en FPGAs de librerías de alto nivel para Reinforcement Learning y de la librería LibSVM. The sustained demand for higher computational performance has intensified the adoption of heterogeneous computing platforms that integrate domain-specific accelerators alongside general-purpose processors. Among these technologies, Field-Programmable Gate Arrays (FPGAs) offer a compelling balance between performance, flexibility, and energy efficiency. However, their practical adoption remains limited by the complexity of hardware/software partitioning and the challenges associated with accelerator design, particularly when targeting applications developed with high-level software libraries. This dissertation presents a systematic, vendor-agnostic methodology for the early-stage acceleration of compute-intensive applications on FPGA-based heterogeneous architectures. The proposed approach formalizes the hardware/software partitioning process as a constrained optimization problem and incorporates early performance estimation, communication cost modeling, and design-space exploration through High-Level Synthesis (HLS). By emphasizing quantitative decision support in the initial phases of development, the method reduces reliance on costly iterative prototyping. The methodology is experimentally validated using representative Machine Learning workloads implemented with high-level libraries, specifically AI-Toolbox for Reinforcement Learning and LibSVM for Support Vector Machines. The resulting implementations achieve overall speedups of up to 24× and 188.69×, respectively, while maintaining application-level correctness and resource constraints. Beyond performance gains, the proposed framework significantly streamlines the accelerator development workflow and provides structured guidance for early feasibility assessment. To the best of the author’s knowledge, this work constitutes the first documented FPGA-based acceleration of high-level Reinforcement Learning libraries and of the LibSVM library within a systematic methodological framework.
Bayesian neural networks represent model parameters using probability distributions and can provide information about parameter and predictive uncertainty. However, the sampling operations associated with Bayesian inference can increase computational and hardware requirements, in resource-constrained embedded systems. This work investigates an implementation-oriented workflow for converting a Bayesian-trained neural network into a deterministic fixed-point representation for FPGA-oriented evaluation. A BNN was trained on the MNIST handwritten-digit dataset using variational inference. Following training, the posterior means of the learned parameters were extracted to construct a deterministic approximation, thereby removing stochastic parameter sampling during inference. The resulting deterministic model was quantized using QKeras with a 10-bit fixed-point representation and evaluated in software. A separate fixed-point representation of the deterministic model was used to generate a custom Verilog-oriented implementation for RTL verification and FPGA-oriented analysis. The Bayesian neural network achieved a classification accuracy of 94.01\% on the complete MNIST test dataset using 30 Monte Carlo samples, while the posterior-mean deterministic model achieved 93.98\%. The 10-bit quantized software model achieved 93.87\% on the same test dataset. The available synthesis results reported 2,474 lookup tables, 2,201 flip-flops, and 141 DSP resources. The reported power consumption of 1.665 W was obtained through Vivado power estimation and therefore represents a tool-based estimate rather than a direct board-level measurement. Hardware-oriented validation was limited to directed test vectors and was used to verify the functional operation of the RTL implementation rather than to establish complete test-set accuracy. The results demonstrate the feasibility of converting a variationally trained Bayesian neural network into a deterministic and quantized FPGA-oriented representation. However, explicit uncertainty estimation is not retained after posterior-mean conversion, and complete hardware test-set accuracy, measured latency, and board-level power consumption were not established. The study therefore presents an implementation-oriented feasibility case study rather than a new Bayesian inference algorithm or FPGA architecture.
To address the challenges of deploying diffusion models on resource-constrained edge devices, this paper proposes a structured pruning scheme suitable for FPGA platforms. The research focuses on algorithm-level optimization and hardware deployment potential analysis without involving complex end-to-end hardware implementation. First, a lightweight diffusion model (e.g., Tiny Stable Diffusion) is used as the baseline. Channel-wise, structured pruning (ln_structured) is applied on the GPU platform. Through iterative pruning and fine-tuning, 30%–50% reduction in parameters and FLOPs is achieved while ensuring generation quality (controllable FID variation and no obvious degradation in image quality), and the inference speed is significantly improved. Experimental results show that the pruned model retains its generation capability while drastically reducing computational and memory overhead, laying a lightweight foundation for subsequent hardware deployment. On this basis, this paper further analyzes the adaptability of the pruned model for FPGA deployment. Theoretical analysis demonstrates that the regular sparse structure introduced by structured pruning can effectively alleviate the memory bandwidth bottleneck of FPGAs and improve the parallel utilization of computing units. A virtual FPGA acceleration architecture is also designed, and high-level synthesis tools are used to estimate resource utilization and performance metrics, quantifying the optimization potential of pruning in energy efficiency and latency. Finally, by comparing the performance of the pruned model with the original model on general-purpose processors, the deployment advantages of the pruned model on FPGA platforms and the subsequent engineering direction are clarified, providing a feasible technical approach for efficient hardware deployment of diffusion models.
This paper describes a 10-bit successive approximation register (SAR) ADC designed in Cadence Virtuoso and simulated with Spectre on the 180 nm gpdk180 process. The converter has a bootstrapped sampling switch, a binary-weighted charge-redistribution capacitor DAC (10 fF to 5.12 pF), a StrongARM latch comparator, a 12-state SAR controller and a 10-bit output register, all driven by one 1 MHz, 5 V clock. The transistor-level cells were checked one by one, and the whole converter was checked with Verilog-A behavioural models. A conversion takes 12 clock cycles, giving 12 µs, 83.3 kS/s and a 4.883 mV LSB. With a 10 kHz, 2.5 V ± 0.1 V sine input, bits D9 to D0 come out in order, the output register loads only on the register clock, and the output lags the input by one conversion. The recorded output matches an ideal quantiser in all 40 conversions. INL lies between −0.33 and +0.50 LSB, DNL between −0.42 and +0.39 LSB, there are no missing codes, the SNR is 33.7 dB and the ENOB is 9.95 bits. The kT/C noise of the 10.23 pF array is 20.1 µV rms (0.4% of an LSB).
Harshada Dalvi +30Global Journal of Engineering and Technology Advances
This paper proposes novel hardware architectures for energy efficient a p proximate c o mputing a p plications. The development of low power, high speed arithmetic architectures has become increasingly important for error-tolerant applications such as image processing, multimedia systems, and edge-AI accelerators, where approximate computing plays a significant role. However, most of the state-of-the-art approximate multipliers primarily focus on arithmetic simplification a nd e rror reduction, while the optimization of switching activity and hardware power dissipation can be further explored in hardware design. To address these challenges, this work proposes ASPIRE, an Adaptive Switching Activity Aware Approximate Multiplier with Dynamic Transition Reduction, designed to minimize signal transitions and reduce dynamic power consumption while maintaining acceptable computational accuracy for low power systems. An on-the-fly switching activity monitoring technique is incorporated into the proposed architecture, which dynamically monitors signal transitions across internal modules. In order to reduce dynamic power consumption and inhibit superfluous transitions, a low power reconfigurable b us-encoding a p proach is selectively triggered based on the observed switching behavior. FPGA implementation results demonstrate a total power consumption of 0.111 W to 0.113 W with dynamic power of 0.020 W to 0.022 W, while ASIC synthesis in 45 nm and 90 nm CMOS technologies further validates the effectiveness of the proposed architecture in achieving reduced power consumption and improved energy efficiency with high performance.
Shantinikethan Sidharth +10International Symposium on VLSI Design and Test
This paper presents an FPGA-based implementation of a Generative Adversarial Network (GAN) generator for lowlatency image synthesis on edge devices. Unlike conventional GPU-based approaches, the proposed work deploys a fully connected GAN generator on a resource-constrained PYNQ-Z2 FPGA platform, using a complete hardware design flow that includes Vivado and Vitis. The generator, trained on the FashionMNIST dataset, consists of multiple fully connected layers that map a low-dimensional latent vector to $\mathbf{2 8} \times \mathbf{2 8}$ grayscale images. The key novelty of this work lies in the integration of a fixed-point optimized hardware architecture with an efficient FPGA deployment pipeline. The trained floating-point model is quantized and synthesized using Vitis, while Vivado is utilized to manage hardware acceleration and AXI DMA-based communication between the processing system and programmable logic. Experimental results demonstrate that the proposed system achieves an average inference latency of approximately 14.08 ms per sample, enabling real-time performance on edge hardware. The results highlight the effectiveness of combining FPGA acceleration and optimized deployment tools for practical generative AI applications in lowpower embedded environments.
B. S. Surya +30International Symposium on VLSI Design and Test
Deploying Transformer models on FPGA and System-on-Chip (SoC) platforms remains challenging due to their substantial computational complexity, large memory footprint, and high hardware resource requirements, particularly in multi-head attention and stacked encoder-decoder layers. This paper proposes a hardware-efficient Transformer acceleration framework based on high-level synthesis (HLS) for resource-constrained FPGA platforms. The proposed framework introduces a reuse-oriented architecture that minimizes redundant hardware instantiations across Transformer components with identical computational behaviors. Instead of implementing independent processing units for each attention head, a shared attention engine is iteratively reused across multiple heads to reduce arithmetic and memory overhead. In addition, shared hardware blocks are employed for Add & Norm operations as well as encoder and decoder layers through iterative execution, significantly reducing logic utilization and on-chip buffering requirements while preserving the original Transformer computation flow. To further improve hardware efficiency, low-precision quantization techniques, including 16-bit Fixed point and 8-bit Integer, are integrated to reduce hardware computational cost, memory bandwidth demand, and power consumption. The proposed framework is evaluated using BERT (MRPC benchmark) and Transformer-based models on FPGA platforms. Experimental results show that the proposed design reduces BRAM utilization by up to 87.5%, LUT utilization by 80.4%, and FF utilization by 64.2% compared with conventional 32-bit Floating point implementations, while 8-bit Integer quantization reduces power consumption from 1.83 W to 1.01 W and increases the maximum operating frequency from 124.08 MHz to 262.12 MHz.
Xuan-Hai Tran +10International Conference on Multimedia Analysis and Pattern Recognition
Approximate computing has become a promising approach to low-power computing and hardware simplification in error-tolerant computations, including image and signal processing. In this paper, an adder optimization of an Approximate Compressor-based Modified Least Significant Column-Carry Aware Column (ACMLC-CAC) multiplier is presented. In contrast to the more traditional architectures that use a fixed adder, the presented design examines various adder design, such as Ripple Carry Adder, Carry Look-Ahead Adder, Carry Select Adder, and Brent-Kung Adder to optimize performance on the most important metrics. The architecture, through the addition of these adders to the accumulation stage, provides flexibility in trade-offs between area, delay, power consumption, and computational accuracy. The proposed designs are generated with the help of Verilog HDL and synthesized in a Xilinx Artix-7 FPGA platform. The results of the experiment indicate that the area and power-delay product is reduced considerably in comparison with precise multiplier designs. Moreover, the evaluation of image quality in terms of Peak Signal-to-Noise Ratio proves that the approximation creates an insignificant perceptual distortion, which makes the method extremely appropriate to be used in practice as the error resilient approach.
Pigging is widely employed to remove deposits from water distribution pipelines, yet technical guidelines for determining the optimal number of passes remain insufficiently established. This study investigates the mechanistic reason why repeated pigging provides superior cleaning performance compared with a single pass by integrating visualization experiments and computational fluid dynamics (CFD) analysis. A serrated scraper pig, consisting of two rows of circumferential serrated rubber pads with a Shore hardness of 60D, was tested in a laboratory-scale recirculating system using a 100 mm diameter transparent acrylic test pipe and artificial sediments designed to simulate strongly adhered pipeline deposits. Direct visualization showed that the second pigging pass achieved a sediment removal efficiency of 37.55%, which was approximately five times higher than that of the first pass (7.46%) and substantially greater than that of conventional flushing (0.55%). Transient CFD simulations (pimpleFoam solver with the γ – Re θ transition model coupled to the shear stress transport (SST) k – ω turbulence model) clarified the physical basis for this enhancement. During the first pass, sediment accumulation within the serrated pad gaps suppresses bypass flow development. After these gaps are partially cleared, accelerated annular flow develops more effectively during the subsequent pass, increasing the local wall shear stress and skin-friction coefficient in the noncontact regions. This combined action of mechanical scraping and hydrodynamic shear explains why the major cleaning effect appears primarily after the first pass. The main practical implication is that at least two pigging passes are recommended for the effective removal of strongly adhered deposits. These findings provide a mechanistic basis for optimizing pigging protocols in water distribution pipeline maintenance.
Wondal Jung +50Journal of Pipeline Systems Engineering and Practice
Manufacturing systems must simultaneously reduce resource intensity and maintain operational continuity under disruption, yet most real-time control architectures do not incorporate circular-economy and resilience objectives within production decision making. This study develops and evaluates a Digital Twin (DT) framework that functions as a decision engine for Industry 5.0 production systems rather than as a monitoring-only representation. In this framework, the DT remains synchronized with the physical line through live IoT data, a credibility gate that suspends prescriptive actions when synchronization error exceeds acceptable bounds, a provenance ledger that records material recovery events, and a multi-objective scheduler that balances energy consumption, waste generation, and delivery delay under human approval. Circularity is operationalized as the share of material recovered through reuse or recycling, whereas resilience is quantified as normalized recovery performance following a disruption. Using a design science approach, the framework was implemented for six months on an operating electronics manufacturing line in Riyadh, Saudi Arabia, covering 3,048 production lots. The evaluation combined a two-month baseline, a four-month intervention period, and disruption scenarios for supplier delay, machine breakdown, and quality shift events. The intervention reduced energy intensity by 14.4%, decreased weekly downtime by 23.9%, and increased overall equipment effectiveness by 5.0% while maintaining product quality. The circularity rate increased from 0.23 to 0.33, with larger gains for packaging and casings than for printed circuit boards because of component-specific reuse constraints. Resilience scores increased from 0.71 to 0.82, indicating faster recovery from supply and equipment disruptions. These findings show that a traceable, credibility-gated, human-supervised DT can align shop-floor decisions with circularity and resilience objectives, although the reported gains should be interpreted in light of the single-line pilot context.
Ragu Prasadh Rajendran0International Journal of Industrial Engineering and Management
Depression screening relies largely on periodic self-report instruments, which can miss gradual behavioural change between assessments. Wearable devices continuously record sleep, physical activity and heart rate, yet published studies differ widely in data type, labelling and validation rigour, and evidence on participant-independent generalisation remains limited. This paper presents a complete, pre-specified study design for early depression-risk screening support from wearable-derived data, with a leakagecontrolled comparative framework for classical machine learning, deep learning and statistical time-series baselines, and a multi-method explainable-AI analysis (SHAP, LIME, permutation importance, partial dependence). We audit four public or access-controlled datasets (Depresjon, GLOBEM, RADAR-MDD, StudentLife), document which required modalities each contains, and assign them to separate, non-pooled experiments. We define sleep, activity, physiological and circadian features mathematically, specify nine experiments (A–I) covering modality ablation, model comparison, cross-subject and temporal generalisation, and robustness to missing or noisy data, and describe calibration, cluster-bootstrap confidence intervals and multiplicity-corrected significance testing. No experiments have been executed for this manuscript: all result tables are marked templates, and every quantitative statement about prior work is attributed to its source. The framework targets research screening support, not clinical diagnosis.
P. P.0International Journal for Research in Applied Science and Engineering Technology
The IIoT-Based Automatic Roller Gadget for Industrial Workers and Visitors is designed to provide convenient, efficient, and controlled mobility within large industrial facilities. The proposed system integrates an Arduino ATmega328P controller, Bluetooth module, smartphone application, DC geared motors, motor driver, ultrasonic sensor, LCD display, buzzer, navigation control, voltage sensor, and rechargeable lithium battery. The smartphone application communicates with the controller through Bluetooth, enabling users to operate the roller gadget wirelessly. The Arduino processes the received commands and controls the motor driver to regulate wheel movement and direction. The ultrasonic sensor detects nearby obstacles and helps improve operational safety, while the buzzer provides audible warnings during potentially unsafe conditions. The voltage sensor monitors battery voltage, and the LCD displays essential operating information. The rechargeable battery supplies power to the electronic components and motorized mechanism, supporting portable operation. The proposed gadget aims to reduce physical effort and improve movement efficiency for workers and visitors travelling between different locations within industrial premises. Its compact design and integrated control system offer potential applications in factories, warehouses, workshops, and industrial campuses. Prototype development and testing can evaluate its mobility, obstacle detection, battery performance, and operational reliability under controlled conditions
Vaibhavi Shahade +60International Journal for Research in Applied Science and Engineering Technology
Blockchain platforms for peer-to-peer energy trading often add a digital twin that forecasts each meter's generation and demand. In most designs the twin only raises alarms, while validators are still chosen by stake or computation. The proposed scheme, PoET²S, incorporates the twin's evidence into validator selection: a node's weight is a stake-and-energy term multiplied by its Twin-Trust Score raised to γ = 2.5, so nodes that contradict the physical forecast quickly lose committee seats. A discrete-event simulator compares PoET²S (500 nodes, 15% Byzantine, 30 paired seeds) with seven classical baselines and three design points from recent work: a binary veto, an additive energy-and-trust score, and a linear (γ = 1) reputation weight. Detection is a near-tie: PoET²S catches 91.0% of attackers and the veto 91.7%. PoET²S raises more false alarms per catch by default (13.9 against 9.7) but matches the veto's catch rate at equal false-alarm cost. The malicious committee share is 10.8% under the veto, 3.8% under the linear weight, and 2.6% under PoET²S, and on 100 seeds the gain over the linear weight is 37% (Holm-adjusted p = 7.2 × 10⁻⁹). At 45% Byzantine nodes, the one-third fault bound fails in 64.4% of veto blocks and 2.4% of PoET²S blocks. Simulated commit latency (30.2 ms) is higher than for Proof of Stake and Delegated Proof of Stake, lower than for Practical Byzantine Fault Tolerance, and flat up to 4,000 nodes; an optional fast path lowers it to 26.8 ms. Against Sybil attacks, top-K selection needs certified meter identities.
The study justifies theoretical and methodological foundations of proactive operational efficiency management in mining companies within the Industry 4.0 paradigm. Its relevance is explained by a divergence between the following two processes. The physical volume of the gross value added in the Russian mining industry declined by 1.7% in 2025 with the mining and geological conditions deteriorating measurably, e.g. the stripping ratio at the Polyus Group rose from 1.5 to 2.4 m³/t in a single year, while the coal production cost grew from 2,234 to 3,400 Rubles per tonne. At the same time, the utilization capacity factor of the open-pit excavators remains at 0.45–0.49 against 0.80–0.90 in the record-high months. A hypothesis is made that in the cyber-physical production the measurement costs cease to be an exogenous parameter and become a design variable, which shifts the whole configuration of the in-company control. The objective is to justify a conceptual model combining noninvasive real-time monitoring, dynamic labour rate setting and minimisation of the in-house transaction costs. The methods used include comparative analysis, content analysis of corporate reporting, decomposition of the equipment time fund and theoretical modelling. A four-level closed cybernetic control loop is proposed; control costs are decomposed into measurement, monitoring and enforcement; an observability index and a proactivity reserve are introduced. It is demonstrated that the selective photochronometry detects on average 1.6% of working time losses against 14.0% when recorded continuously at the same facility.
Progress beyond conventional transistor scaling increasingly depends on whether gains in devices, memory, interconnects, compilers, and system software survive integration into complete workloads. The Milutinovic–Katulevskiy Architecture (MKA) develops a common research framework for this problem. Building on Veljko Milutinovic’s Honey- ´ comb architecture and graph-mapping lineage, MKA treats computation, stored state, communication, placement, and physical substrate as one architectural design space. The article formulates a broader system-level principle: a local hardware improvement counts as genuine architectural progress only when its advantage survives data movement, state placement, interfaces and conversion, scheduling and queueing, accuracy, reliability, and servicelevel constraints at the boundary of completed useful work. The proposed MKA Law operationalizes this principle through the energy–time product of completed workloads under fixed quality and service requirements Communication bounds, placement models, uncertainty-aware optimization, and substratespecific break-even conditions determine when locality, reuse, heterogeneous execution, and changes of physical medium can improve the whole system. An exact reference planner makes one part executable. Across a synthetic planning study, coordinated placement improves feasible plans relative to local and fixed-placement strategies; strong global alternatives recover most of that benefit. Full accounting for movement and setup prevents decisions that look attractive locally but fail system constraints. These results establish a starting point for calibrated hardware, concurrent graph workloads, and experimental implementations. MKA follows the quantitative architecture tradition developed by John L. Hennessy and David A. Patterson, where workload, compiler, machine, memory, communication, and implementation technology are evaluated together. Oskar Mencer’s dataflow work supplies an implementation precedent for compilerdirected spatial execution. Mor Harchol-Balter’s queueing and server-power research connects execution capacity to delivered service. Dimitris Bertsimas’s robust and prescriptive optimization provides the uncertainty-aware decision layer. Daniela Rus’s graph grammars, decentralized control, and physical co-design motivate search over realizable, controllable structures. MKA organizes these ideas into six regimes spanning reconfigurable digital fabrics, analog computation, processing near memory, photonic interconnects, quantum-dot systems, and entanglement-assisted architectures for quantum-native workloads. Artificial intelligence infrastructure provides an immediate high-pressure application, while scientific simulation, finance, genomics, telecommunications, and other graph-intensive domains broaden the research space. At datacenter scale, sustained system-level efficiency improvements could translate into major reductions in energy use and operating cost; in science, the same gains could enlarge the computations achievable within finite power and time budgets. MKA therefore proposes more than an individual accelerator design: it establishes a shared architectural language and an experimentally falsifiable research direction intended to carry useful design knowledge across successive generations of computing technology. Prospectively, the MKA Law can be applied to open-weight LLM serving as a six-vector optimization over compute and precision, resident weights, KV and request state, expert and interconnect routing, batching and queueing, and active capacity with its power and cooling burden. Llama 4 Maverick, GLM-5.3, Kimi K3, and Qwen3.8 expose different resource demands, motivating model-specific operating-point searches. At hyperscale, the economic leverage is substantial: under a 5-GW average AI-serving load, PUE 1.20, and electricity at $0.07/kWh, every 10% reduction in system-level IT energy per completed request corresponds to approximately $368 million in annual electricity savings at fixed demand and unchanged PUE. A 30% reduction would exceed $1.1 billion annually. These figures are sensitivity thresholds, not assumed MKA performance, and illustrate the scale at which experimentally measured system-level gains would translate into economic impact.
A heterogeneous accelerator is proposed for efficient edge inference of hybrid CNN–Transformer vision networks. The architecture integrates a reconfigurable systolic array (SA), a vector processing element (VPE) array and a reduction core (RC) to support diverse computation patterns. The SA is reconfigured for standard, pointwise and depthwise convolution and one‐level Strassen MatMul, while multi‐level Strassen MatMul is jointly executed by the SA and VPE array to reduce the multiplication workload. Fixed‐point nonlinear operators are processed by the VPE array and RC, enabling integer‐only execution with high hardware utilization. Architectural modelling predicts up to 1.58 speedup over standard MatMul. FPGA measurements show 363.2 FPS on EfficientViT‐B1 and 277.1 FPS on MobileViT‐XS.
Deploying deep neural networks to analyze simulated astrophysical observations often introduces substantial computational overhead and severe model over-parameterization. Standard scientific machine learning workflows frequently rely on large computer vision backbones that overfit limited training sets and require labor-intensive hyperparameter tuning. We present DLens, a multi-agent framework designed according to Parsimonious Scientific Machine Learning (ParSciML) principles to identify low-mass dark matter substructures in strong gravitational lensing observations. DLens integrates physical lensing simulation backends (lenstronomy and pyHalo) with an interactive Large Language Model (LLM) architecture search and experiment planning loop. To prevent prompt context inflation, DLens uses structured Pydantic data schemas to decouple high-level experimental reasoning from raw image arrays. Under sample-constrained conditions (1, 800 training images), DLens combines a tree-based architecture search across valid neural network candidate families with a ReAct optimization planner that inspects scalar validation metrics to apply targeted hyperparameter adjustments. Evaluated on a 3-class dark matter substructure benchmark (no substructure, cold dark matter, and ultralight axion dark matter), DLens discovers a compact convolutional neural network (cnn_medium_s4, 2.54M parameters) achieving 87.06% accuracy on a held-out test dataset. This improves upon a ResNet-34 baseline (81.00%, 21.28M parameters) by 6.1 percentage points while achieving an 8.4× reduction in parameter scale (88.1% parameter reduction). The complete search and tuning pipeline runs in 21.0 minutes on a single workstation, demonstrating computational parsimony and reproducible workflow verification.
Modern computer vision is increasingly driven by the search for representations that generalize across tasks, modalities, and learning settings, rather than excelling at a single benchmark. This has produced a broad collection of architectures and paradigms, including convolutional neural networks (CNNs), Vision Transformers (ViTs), state-space models, foundation models, and diffusion-based generative models. Despite differing in design and training objectives, these approaches increasingly draw on a common set of principles: representation learning, self-attention, self-supervision, multimodal alignment, and generative modeling. As a result, the boundaries between discriminative, multimodal, and generative paradigms are becoming progressively less distinct. This survey examines that convergence through the lens of representation learning. We introduce a formal framework that classifies architectures by which component of an encoder–decoder pipeline they modify, unifies diverse training objectives as instances of a single alignment functional, and formalizes the locality–globality trade-off through two provable relationships linking a model’s locality, its computational cost, and the depth required to reach a global receptive field. Using this framework, we trace the evolution of vision architectures, from convolutional networks and Vision Transformers through hybrid and state-space designs to multimodal foundation models and modern generative frameworks, critically examining the limitations of each paradigm rather than reporting only their successes and complementing this analysis with a quantitative comparison across representative architectures. We show how discriminative, multimodal, and generative learning are converging around shared representational principles, argue for a unified representation-learning perspective on modern computer vision, and outline open challenges and concrete future directions toward general-purpose visual intelligence, multimodal foundation models, and trustworthy deployment.
Deep networks are usually built first and trained later, forcing fixed capacity and wasted compute. We introduce the Autoplastic Neural Network, a training-time framework that learns structure and weights together. Layer inclusion, neuron-level connectivity, and per-layer operation mixing are jointly optimized within a fixed maximal supernetwork, whose pre-allocated components are reinforced or pruned as learning progresses; the resulting model supports per-input routing and can also be exported as a compact static architecture. A stability-gated rule coordinates architectural changes with gradient descent and yields convergence guarantees. Across vision, video, language, bioinformatics, and healthcare tasks, the approach surpasses strong static and dynamic baselines while using less computation. Unlike neural architecture search, no outer search loop is required; evolution happens inside a single learning process with cost comparable to training a single model. By unifying optimization and design, Autoplastic networks allocate capacity where needed, remove redundancy when possible, and deliver practical, resource-aware deep learning.
Introduction: Hemorrhagic transformation remains a major complication after acute ischemic stroke, particularly following reperfusion therapies such as thrombolysis and mechanical thrombectomy. Artificial intelligence and radiomics models have emerged as promising tools for early risk prediction using neuroimaging data. We performed a systematic review and diagnostic meta-analysis evaluating the performance of AI-based models for hemorrhagic transformation prediction. Methods: PubMed, Embase, Scopus, and Web of Science were systematically searched from inception through May 2026 for studies evaluating artificial intelligence, machine learning, deep learning, or radiomics models predicting hemorrhagic transformation after acute ischemic stroke. A bivariate random-effects and hierarchical summary receiver operating characteristic model were used to pool diagnostic performance metrics, including sensitivity, specificity, and area under the curve. Results: A total of 10 studies comprising 3,278 patients with acute ischemic stroke were included, including 1,846 males (56.3%) and 1,432 females (43.7%). Mean age ranged from 61.2 to 74.5 years, and 68.4% of patients underwent mechanical thrombectomy. Imaging modalities included non-contrast CT, CT perfusion, CTA, diffusion MRI, and multimodal radiomics datasets. Evaluated algorithms included convolutional neural networks, XGBoost, random forest, support vector machine, LightGBM, and ensemble deep learning architectures. The pooled incidence of hemorrhagic transformation was 21.6%, while symptomatic intracranial hemorrhage occurred in 14.8% of cases. Hierarchical meta-analysis demonstrated pooled sensitivity of 81.3% (95% CI: 77.2-84.8%), specificity of 82.5% (95% CI: 78.9-85.6%), positive predictive value of 74.1% (95% CI: 69.3-78.2%), negative predictive value of 88.4% (95% CI: 84.9-91.1%), diagnostic odds ratio of 20.8 (95% CI: 14.6-29.5), F1-score of 0.79 (95% CI: 0.75-0.83), and pooled AUC of 0.86 (95% CI: 0.83-0.89). External validation cohorts demonstrated comparable diagnostic performance with low between-study heterogeneity. Conclusion: Artificial intelligence and radiomics models demonstrated high diagnostic accuracy for predicting hemorrhagic transformation after acute ischemic stroke, with strong sensitivity, specificity, and external validation performance across imaging modalities. Deep learning and multimodal radiomics approaches showed the greatest predictive utility, supporting their emerging role in individualized stroke risk stratification and precision neurovascular care.
Recently, transformer-based trackers have become the leading approach, surpassing traditional CNN-based trackers in accuracy. However, their high computational demands hinder their deployment on edge platforms, necessitating efficient solutions. To address this, we propose a novel Neural Architecture Search (NAS) framework designed for transformer-based trackers, named NASTrack. This framework incorporates token pruning to optimize both transformer block structures and the layer-wise token keeping ratio, striking a balance between performance and efficiency. To handle the larger search space introduced by the keeping ratio, we propose a blacklist strategy and a matching-based distillation driven by the Token Overlap Ratio (TOR). Our method discovers hundreds of high-performing trackers, with FLOPs ranging from 1G to 18G. The searched trackers consistently outperform existing efficient state-of-the-art trackers such as CompressTracker and LiteTrack under comparable computational budgets.The code and models are available at https://github.com/Cyhoon84/NASTrack.git.
Electronic health records (EHRs) contain complex, interconnected patient data that traditional analytical methods often fail to fully leverage. Graph convolutional networks (GCNs) offer a promising machine learning approach for modeling intricate relationships within tabular, multimodal clinical data to improve medical decision-making and patient outcomes. This scoping review presents the first comprehensive synthesis of current research applying GCNs to EHR data for medical applications. We conducted a systematic literature search across medical databases (MEDLINE Ultimate) and computational academic databases (Academic Search Ultimate, Business Source Complete, Supplemental Index, and Complementary Index), using combined search terms for GCNs and EHRs. Following the Preferred Reporting Items for Systematic reviews and Meta-Analyses extension for Scoping Reviews (PRISMA-ScR) protocols, we screened 56 database-identified papers and five additional articles from citation review. After independent abstract screening and full-text review by multiple reviewers, 25 peer-reviewed English-language studies were included in the final analysis. Medical informatics and critical care were the most common application domains. Clinical tasks performed focused on diagnosis prediction, automated medical coding, mortality risk assessment, and medication recommendation. Hybrid architectures integrating GCNs with models such as Bidirectional Encoder Representations from Transformers (BERT) and recurrent neural networks were employed in 60% of studies. ICU EHR datasets were the most frequently used data source. Temporal trends revealed growing research interest, with eight publications (32% of the total corpus) appearing in early 2024. GCNs demonstrated measurable performance improvements in predictive accuracy, drug interaction identification, and risk stratification over other machine learning approaches. Enhanced clinical decision-making was supported through automated extraction of complex data relationships and improved handling of unstructured clinical text, with applications in critical care, oncology, hematology, and cardiovascular domains. Reported limitations included data-related challenges (68%), model-related issues (60%), and application-level barriers (28%), involving data heterogeneity, model generalizability, and clinical integration. GCNs effectively leverage complex relationships within EHR data to support clinical decision-making across diverse medical domains. The predominance of hybrid architectures and measurable performance improvements demonstrate the technology’s potential to transform healthcare delivery by improving diagnostic accuracy, personalizing treatment recommendations, and facilitating early identification of high-risk patients requiring proactive intervention. A phased, clinically grounded implementation strategy, supported by strong data governance, multidisciplinary integration, and hybrid AI architectures, will be essential for realizing GCNs’ full potential in real-world healthcare settings.
Automated classification of gynecological malignancies from cytological and histopathological images remains a critical yet challenging clinical problem. This task is complicated by inter-class morphological similarity, intra-class heterogeneity, and class imbalance. Furthermore, single-stream architectures may have limited capacity to simultaneously capture fine-grained local morphology, long-range tissue context, and rotation-invariant structural geometry. This paper proposes a tri-stream deep learning framework that integrates a convolutional neural network (CNN), a DeiT-III encoder, and an Angular-Radial Partitioning (ARP) descriptor within a unified multi-stream fusion architecture for gynecological malignancy recognition. The CNN pathway extracts hierarchically structured local morphological features including nuclei boundaries, stromal textures, and micro-architectural patterns. The DeiT-III transformer captures global contextual dependencies between spatially distant tissue regions through multi-head self-attention operating on CNN-derived semantic tokens. The ARP module generates rotation-invariant geometric descriptors by decomposing the image into polar sectors and aggregating edge energy distributions across radial rings and angular wedges. The three streams are fused via concatenation followed by a dense projection layer regularized with L2 weight decay, and a composite loss function combining categorical cross-entropy with focal loss addresses class imbalance during training. Hyperparameter configuration is automated through Status-Based Optimization (SBO), a population-based metaheuristic that systematically optimizes over a joint search space of learning rate, focal loss weight, regularization coefficients, optimizer selection, and scheduling policy by simulating hierarchical social learning. Moreover, Gray-World Standard Deviation (GWSD) normalization and augmentation-based class balancing are applied as preprocessing and data preparation strategies. Experiments are conducted on three benchmark datasets named SIPaKMeD, CIVa, and Mendeley LBC, yielding overall classification accuracies of 97.91%, 99.74%, and 99.48% respectively, with macro-averaged F1-scores of 97.89%, 99.28%, and 99.07%. Ablation, robustness, statistical significance, and cross-validation analyses collectively demonstrate the empirical contribution and complementarity of the architectural components, while GradCAM and LIME analyses indicate that the model emphasizes image regions associated with clinically relevant morphological and tissue-structural patterns.
M. Abdel-Salam +40Machine Learning with Applications
With the projected increase in the detection rate of compact-binary coalescences in the coming decade, there is critical need to develop fast, robust, and scalable alternatives to matched filtering for gravitational-wave searches. Transformer models have revolutionized natural language and audio processing but their application to gravitational-wave astronomy is still largely unexplored. In this work, we introduce \castor, a transformer-based coincident search pipeline for detecting binary black hole gravitational-wave signals from Advanced LIGO detectors. One of the major features of our model is that it allows the false-alarm rate to be estimated via time slides cheaply without requiring repeated evaluations of the neural network. We evaluate \castor\ on datasets from the Machine-Learning Gravitational-Wave Search Challenge (MLGWSC-1) and on approximately five months of real O3b observing strain. When tested on benchmark datasets, \castor\ ranks among the most sensitive machine-learning pipelines and successfully recovers the majority of confident events from the GWTC-3 catalog that lie within its training range. We also benchmark \castor\ against another transformer architecture, GW-Whisper, a domain-adaptation of OpenAI's audio foundation model. We find that \castor\ substantially outperforms the repurposed audio model in sensitivity and also reduces the computational cost of background estimation by a factor of 20. Our results demonstrate a highly practical, scalable approach for deep-learning gravitational wave searches and empirical background estimation for future observing runs.
Background Artificial intelligence, particularly deep learning based on convolutional neural networks, is increasingly applied to dental imaging, including bitewing, periapical, panoramic, cone beam computed tomography, and cephalometric examinations . Aim To synthesise evidence published between 2021 and 2026, alongside one methodologically relevant study published in 2020, on the applications, reported performance, and limitations of artificial intelligence in dental radiological diagnostics. Materials and Methods This narrative review was prepared using SANRA as a methodological reference. PubMed and Google Scholar were searched for publications issued between January 2021 and May 2026. The last search was performed on 21 May 2026. Data on study type, imaging modality, diagnostic task, model architecture, dataset size, performance measures, validation strategy, and reported limitations were synthesised narratively. Results Artificial intelligence has been applied to caries detection, periapical lesion detection, tooth detection and numbering, tooth segmentation, cephalometric landmark localisation, periodontal bone loss assessment, and mandibular canal segmentation. Reported results were favourable for several clearly defined tasks, particularly tooth detection and numbering, but varied substantially across diagnostic targets, imaging modalities, datasets, reference standards, and validation methods. Caries detection showed wide ranges of sensitivity and accuracy, whereas tooth detection and numbering reached F measures of approximately 0.96. Recurrent limitations included retrospective single institution datasets, heterogeneous annotation procedures, limited external validation, and poor comparability between task specific performance measures. Conclusions Current evidence supports the use of artificial intelligence as an auxiliary decision support tool rather than as a replacement for clinical and radiological judgement. Reader studies suggest that artificial intelligence assistance may improve selected diagnostic measures, particularly among less experienced observers, but this benefit has not been demonstrated consistently across all tasks or clinical settings. Further clinical translation requires external validation, more consistent reference standards and reporting, and resolution of ethical, regulatory, and professional liability issues.
Large language model agents increasingly rely on reusable natural-language skills, yet growing skill collections remain accumulations of isolated text artifacts that are difficult to compare, deduplicate, and compose. We argue that the reusable content of a skill lies not in its surface wording but in its procedural transitions: which operation to execute under a given state and which observable outcome to produce. Based on this observation, we propose State-Move-Outcome (SMO), a compilation-like framework that decomposes raw skills into reusable procedural bricks and organizes admitted bricks as an externalized symbolic structure. When compiling a skill, SMO first retrieves and composes existing bricks, dynamically connects them through Outcome-to-State conditions, and creates a candidate brick only for an uncovered procedure; the candidate becomes reusable only after validation and admission. Experiments on SkillsBench v1.1 demonstrate that SMO represents 232 rawSkills from 87 underlying tasks with 95 shared bricks, reducing the corresponding skill representations from 366,472 to 149,154 tokens--a $\mathbf{59.3}\times$ reduction and $\mathbf{2.46}\times$ compression. Across 232 skill-conditioned evaluation instances, SMO raises the average task score from $\mathbf{0.6379}$ to $\mathbf{0.7478}$ and increases 5/5 Pass instances from $\mathbf{138}$ to $\mathbf{164}$, while matching or outperforming rawSkill on $\mathbf{208}$ of $\mathbf{232}$ instances. It also reduces average runtime token consumption by $\mathbf{38.38\%}$. These results show that compiling natural-language skills into shared procedural units can jointly improve skill reuse, representation efficiency, and downstream execution.
Generating accurate CAD models requires substantial engineering expertise and careful control of geometry, topology, and mechanical constraints. Text-to-CAD aims to simplify this process, but current LLM-based methods often generate CAD programs directly. Language models remain unreliable when producing long code while coordinating coupled geometric, topological, and dimensional constraints. Consequently, executable programs may still produce structurally incorrect models, which execution rate and rendered appearance may fail to reveal. To address these limitations, we propose GOPR-CAD, an agentic Text-to-CAD pipeline based on Graph-of-Operations Progressive Reasoning. A language model acts as a decision agent over encapsulated CAD operations and progressively constructs an executable operation graph, which a deterministic compiler converts into the final CAD model. This separation requires no additional training and supports different language models. To evaluate structural fidelity, we construct MHCAD, a benchmark of 300 standard mechanical part requirements derived from Machinery's Handbook. Their explicit structures enable reference-free STEP/B-rep evaluation. GOPR-CAD achieves 82.7% Structural Yield on MHCAD, and 87.2% Structural Yield on an external CADPrompt subset.
Autonomous LLM agents increasingly act through multi-step tool-use graphs, yet their safety is typically enforced by prompts or post-hoc output filters – mechanisms that are opaque, non-portable, and impossible for a third party to audit. We argue that trustworthiness should be a property of the agent graph itself, and that such enforcement is only as trustworthy as the attestation of what it reads. We present Certified Agent Graphs (CAG): a policy compiler turns a declarative invariant language (allowed tools, impact ceilings, evidence/provenance/freshness requirements, rollback and human-in-the-loop conditions, and multi-step invariants such as cumulative-impact budgets and rate limits) into pure runtime monitors; a fail-closed trust guard folds them into one decision per graph transition; and every run emits a signed certificate, independently verifiable via an optional public-key path, that a standalone verifier replays without invoking the model. Against an adaptive, white-box attacker, we show this enforcement is only as strong as its inputs' provenance: without attesting declared fields, an attacker who simply declares compliant values evades the guard as often as every baseline (evasion rate 1.0); attesting them closes that channel to 0.0. The same pattern holds one layer up – an attacker who resets multi-step state by splitting actions across fresh, unauthenticated session identifiers (Sybil) evades stateful invariants at 1.0; attesting session identity closes this to 0.0 as well. Measured against an independent, non-circular harm oracle (validated against a simulated human-rater panel), the guard behaves as a conservative, high-recall (0.926), lower-precision (0.262) detector – corroborated by real Groq, OpenAI, and Anthropic model calls – with bounded overhead and fully reproducible, tamper-evident audit trails.
End-to-end VITS text-to-speech models synthesize natural speech in a single forward pass, yet standard ONNX exports execute monolithically over an entire clause, delaying Time-To-First-Audio (TTFA) to several seconds and spiking activation memory. Client-side deployment across Indic scripts faces four further bottlenecks: 138.8 MB float32 checkpoints per language strain browser caches, mobile WebGPU stalls for 6-14 s compiling convolution shaders while still running slower than real time ($1.44\times$ RTF), small WebAssembly pthread pools stall at barriers on big.LITTLE mobile CPUs, and mobile Web Audio pipelines drop frames or mute output under AudioWorklet contention and iOS WKWebView rules. We present Ninada, an open-source 24 kHz TTS system covering English, Classical Sanskrit, and ten Indian languages (sa, en, hi, kn, mr, bn, ta, te, ml, gu, pa, or) across a capability-routed 48-checkpoint fleet: 24 studio HiFi-GAN v1 specialists (27.9 MB W8A32+FP16 ONNX) for desktop/WebGPU and 24 distilled c8c8_384 iSTFTNet specialists (21.7 MB ONNX, $2.64\times$ fewer vocoder MACs via an exact NOLA dual-window ConvTranspose1d inverse STFT with zero complex ops) for mobile WASM, plus a 0.0 MB zero-dependency Klatt fallback. At runtime, Ninada splits a single ONNX file in memory in $<15$ ms into prior, flow, and windowed vocoder sub-sessions streaming 12-frame halos with raised-cosine crossfades. On $N = 480$ held-out 24 kHz studio utterances, Ninada achieves 3.22 dB 0-8 kHz MCD (3.09 dB mobile iSTFTNet; 1.33 dB 24-voice distillation MCD, vs. 5.17 dB for the 1,526.8 MB 16 kHz Meta MMS fleet) and 6.07 dB 8-12 kHz error, delivering 89-155 ms audible startup on desktop WebGPU and 538-649 ms zero-underrun streaming at 0.75-0.76x RTF on a physical Google Pixel 10 Pro XL.
Whether a precursor-substrate-reactant combination yields an atomic layer deposition (ALD) process is still settled by trial-and-error experiments. Here we introduce AJIN (ALD Joint Interpretable Network), a machine-learning framework that learns this decision from experimental outcomes. We compiled 560 experimentally observed ALD and area-selective ALD outcomes spanning 76 precursors, 27 substrates, 20 reactants and 25-620 degrees Celsius. Following the ALD cycle, AJIN predicts adsorption from graph-neural-network embeddings of the precursor and substrate with temperature, and deposition by adding the reactant. The best model (CHGNet-MLP) reaches balanced accuracies of 79.2% for adsorption and 84.8% for deposition and transfers partially to unseen precursors. SHAP and ablation analyses show that substrate chemistry governs adsorption, whereas precursor, substrate and reactant all contribute to deposition. Tested against our laboratory's ALD experiments, AJIN correctly predicted 83% of new-substrate cases and 71% of new precursor-substrate adsorption cases, providing an experimentally grounded tool for prioritizing ALD and area-selective ALD chemistries.
Modern oil and gas processing and petrochemical industries are characterized by increasingly stringent requirements for energy efficiency, environmental safety, and product quality. Design, optimization, and digitalization of technological processes are impossible without a reliable description of the phase equilibrium of hydrocarbon and multicomponent mixtures. An adequate description of phase equilibrium is critically important for calculating rectification, absorption, and separation processes, since errors in distribution coefficients lead to incorrect determination of the number of theoretical stages, reflux ratio, and equipment loads. In the context of import substitution and the development of domestic engineering software, the creation of accessible, transparent, and reproducible calculation modules that are not inferior in accuracy to commercial packages is of particular importance. Such developments are important for the educational process and research groups limited in access to expensive foreign licenses. The presented article proposes an algorithm for calculating phase equilibrium between vapor and liquid phases using the Peng-Robinson equation of state based on the bisection method and damped substitution. The choice of the Peng-Robinson equation is due to its wide application for hydrocarbon systems, satisfactory accuracy in subcritical and supercritical areas, and the possibility of calculating the compressibility factor, fugacity coefficients, and phase enthalpy. The implementation was carried out in C# using the WPF graphical library, which provides a convenient interface for selecting components, specifying material streams, viewing properties, and constructing diagrams. The modular software architecture simplifies maintenance, database expansion, and integration of new calculation methods. A property database of 27 individual components has been compiled; binary interaction parameters for 4 selected systems have been determined by regression; graphs in p-x,y and t-x,y coordinates have been constructed. The database includes critical parameters, acentric factor, temperature dependences of heat capacity, and enthalpy of formation of components. It is shown that the model satisfactorily describes systems with near-ideal behavior and systems exhibiting retrograde condensation. At the same time, for systems with azeotropy and strong association of components, the accuracy of description are insufficient. To further improve the model, it is necessary to modify the mixing rules, collect additional experimental data, perform regression of interaction parameters, and implement the calculation of equilibrium between two liquid phases using activity coefficient models, e.g., NRTL, and the Wong-Sandler and Huron-Vidal equations. The practical significance of the work consists in the creation of domestic software that can be used for teaching, scientific research, and engineering calculations of oil and gas processing. The developed modules can be integrated into computer-aided design systems and used for the analysis of energy- and resource-saving schemes. Thus, the proposed approach develops the methodological and software foundations of thermodynamic modeling and creates prerequisites for import substitution in the field of engineering software.
Дан Русланович Шарафутдинов +20Oil and Gas Business
Deep Learning (DL) accelerators are widely adopted for their efficiency and cost-effectiveness, and increasingly embedded in robots and autonomous vehicles. Their heterogeneous architectures, however, introduce security threats across the chip lifecycle, and existing exploration tools cover them only partially, especially before deployment. We propose Gem5-Shark, a framework built on Gem5-Aladdin’s Smaug for cycle-level heterogeneous SoC simulation. It integrates eight configurable threat vectors, comprising seven active attacks and one passive Reverse-Engineering (RE) analysis, spanning the dataset integrity, model compilation, System-on-Chip (SoC) communication, and accelerator execution stages. The two compilation-stage attacks, Operator Attack (OPAtt) and Tiling Attack (TAtt), are new to this work and model toolchain compromise, while the remaining vectors adapt prior threat models, unified for the first time in one heterogeneous simulator. Across Minerva, LeNet-5, and VGG-16, Data Poisoning Attacks reduce inference accuracy by up to 97.7%, Tiling Attacks increase accelerator cycles and energy by up to 44% and 56%, respectively, and Operator Attacks drive accuracy to near-random on full test sets with an attack success rate up to 0.93. At the system level, Denial-of-Service and Flit Loss Attacks raise communication latency by up to 30× and memory delays by up to 84×, Data Swapping Attacks flip the prediction once weight tiles are swapped, and False Flag Scheduling Attacks add over 7× latency overhead. The RE analysis recovers convolutional and fully connected structure from finish-flag timing with 0.978 accuracy when the attacker can calibrate against the target, but not per-layer hyperparameters. On pretrained LLMs of up to 8B parameters, as few as 20 poisoned fine-tuning samples implant a backdoor, the finish-flag attack slows a decoder layer by 4.3 ×, and timing reveals the context length. Two defenses, a compiler-stage tiling range check and a host-side finish-flag watchdog, each remove over 99% of the injected overhead on CNNs and LLMs.
Hao-Yu Wang +30ACM Transactions on Embedded Computing Systems
Pakistan faces a compound threat environment in which a resurgent militancy co-exists with poliovirus transmission, climate-driven disasters, macroeconomic stress, cyber-crime and large cross-border population movements. This study designs and tests a data-centric predictive intelligence framework that fuses these non-traditional security (NTS) signals for anticipatory early warning. Using a real-data annual panel for 2010–2025 compiled from 15 institutional sources (PIPS, SATP, CRSS, PICSS, IEP-GTI, WHO-GPEI, NIH, NDMA, World Bank, FIA, UNHCR-IOM), we estimate a Bayesian multi-source state-space model that reconciles definitionally inconsistent violence series into a latent Militancy Threat Factor (MTF). The factor is analysed with an econometric core sieve-bootstrap ADF, KPSS and Zivot–Andrews tests, Bai–Perron multiple breaks, a Hamilton Markov-switching model, bootstrap ARDL bounds tests, Toda–Yamamoto causality, multiple-imputation dynamic regression, quantile regression and NB2 count models and forecast with six deep architectures (deep MLP, LSTM, GRU, temporal convolutional network, Transformer encoder and Attention-LSTM) trained with sieve-bootstrap augmentation, deep ensembles and Monte-Carlo dropout under strict rolling-origin evaluation. The MTF shows three statistically dated breaks (2016, 2019, 2023; bootstrap sup-F p ≤ 0.004) and a persistent escalation regime since 2021 (expected duration ≈ 11 years). Recurrent networks achieve the lowest out-of-sample error (Attention-LSTM RMSE = 0.290 versus 0.342 for a random walk and 0.300 for AR(1)), with zero false alarms and a Brier skill score of 0.31, but Diebold–Mariano tests do not establish significant superiority on nine test years, and no model anticipated the 2021 turning point. Explainability analysis identifies inflation as the dominant learned predictor. Threats are spatially concentrated: Khyber Pakhtunkhwa and Balochistan account for 96% of 2025 attacks, and provincial militancy and polio burdens co-locate (Spearman ρ = 0.88). The paper offers a transparent, reproducible template that couples latent-state econometrics with uncertainty-aware deep learning, and it reports the evidential limits of annual data candidly positioning deep models as regime-aware decision-support tools rather than oracles.
Classical networks treat every bit as equally important, which wastes time and energy in factories and requires extra traffic engineering for critical traffic. Semantic communications send only what a task needs, but how can they be tested under realistic conditions? This paper examines what can be tested today in 6G industrial IoT, that is, networks of factory machines, robots, and sensors, and what is still missing. It introduces semantic importance, a score attached to each message that states how much the message matters, and uses it in a context-driven design to derive eight testing needs. Existing simulators, emulators, testbeds, codecs, and learning frameworks are assessed against these needs, which reveals five gaps. We propose a toolchain of four components built around the ns-3 simulator for simulated and emulated scenarios.
Water pipeline leakage is a major challenge in water distribution and supply systems because undetected leaks can result in water loss, infrastructure damage, economic losses, and inefficient water management [5], [13]. Conventional leakage inspection methods often depend on manual inspection, periodic maintenance, or specialized equipment, which may not provide continuous real-time monitoring [5], [13]. Recent developments in the Internet of Things (IoT), sensor technology, artificial intelligence (AI), and machine learning (ML) have created opportunities for automated and intelligent pipeline monitoring [9], [11]. This review presents a study of recent techniques used for water pipeline leakage detection, localization, prediction, and monitoring. Different sensing approaches, including flow, pressure, acoustic, and vibration measurements, are reviewed along with machine-learning and deep-learning methods [1], [3], [4], [8], [12], [13]. Existing research demonstrates that pressure and flow measurements are widely used for hydraulic anomaly detection, while vibration and acoustic measurements can provide additional information about leakage events [5], [6], [7]. AI models such as Artificial Neural Networks, Random Forest, Support Vector Machines, K-Nearest Neighbors, Convolutional Neural Networks, and ensemble techniques have been investigated for leakage classification and localization [1], [3], [4], [8], [12], [13]. IoT-based systems further enable continuous data acquisition, remote monitoring, and real-time alerts [9], [11]. However, challenges remain in obtaining representative real-world datasets, reducing false alarms, handling sensor noise, and deploying models on resource-constrained edge devices [13], [14], [15]. Based on the reviewed literature, a multi-sensor IoT and AI architecture using flow, pressure, and vibration measurements with Raspberry Pi-based processing is proposed as a suitable direction for a low-cost academic prototype [5], [9], [11], [12]..
Sakshi Santosh Dhainje C. V. Nalawade +10International Journal of Advanced Research in Science, Communication and Technology
Reliable operation of central cooling and standalone air-conditioning systems is essential to environmental stability, equipment protection and operational continuity in mission-critical facilities such as a central bank. Maintenance of these systems in Tanzania, however, remains predominantly reactive and time-based, producing frequent failures, excessive downtime, and avoidable costs. This study developed and internally validated a Predictive Maintenance Management System (PMMS) to improve the reliability of the central cooling and standalone air-conditioning systems at the Bank of Tanzania (BoT), Dar es Salaam. A mixed-methods case-study design was adopted, with the facility as the unit of inference. A census of the 35 maintenance personnel was conducted (33 usable responses; 94.3%), and a separate equipment-level data set of 51 complete failure-event records (of 52 over 2023–2025) was compiled from maintenance logs and condition-monitoring sensors. Data were analysed using descriptive statistics, Pareto analysis, failure mode and effects analysis (FMEA), Pearson correlation, stepwise multiple linear regression, and machine learning (Random Forest and Support Vector Machine). Compressor-related and refrigerant-leak modes dominated the failure burden; four modes accounted for 63.8% of downtime, and five exceeded the FMEA action threshold (RPN ≥ 200). The regression model explained 78% of the variance in time to failure (R² = 0.78; F(3,47) = 55.78; p < 0.001), with vibration, bearing temperature, and current-draw deviation as significant predictors. In internal validation, Random Forest achieved 87.5% classification accuracy (AUC-ROC 0.92) in development and 75% in an eight-unit field pilot. On this basis, the PMMS is projected to raise system availability from 98.9% to 99.6% and to deliver net annual savings of about TZS 48.5 million with a seven-month payback. The study demonstrates that integrating IoT-enabled condition monitoring with statistical and machine-learning techniques provides a technically feasible, statistically validated, and economically viable PMMS for institutional cooling systems in a developing-economy setting.
Godfrey Isack +10East African Journal of Engineering
The purpose of this paper is to develop a blockchain-enabled, Internet of Things (IoT)-based intelligent system for indoor environmental quality and health monitoring process. In the IoT system, the DHT11 temperature and humidity sensor, MQ135 air quality gas sensor and MAX30100 pulse oximeter sensor were connected to an Arduino Uno micro-controller to obtain readings which were pushed onto a remote client, i.e. the Raspberry Pi 3B+. The data was transmitted through a secure blockchain channel and retrieved on a local server whereby machine learning algorithms such as multi-layer perceptron (MLP) and long short-term memory (LSTM) were used for prediction. The results of the blockchain analysis demonstrate that for an increasing array size, the number of blocks decreases and, in turn, time complexity increases, latency increases and throughput decreases. Data readings transmitted in numerous smaller blocks are more secure than data transmitted in few larger blocks. LSTM predicted SpO2 levels with an average accuracy of 99.00% while MLP predicted SpO2 levels with an average accuracy of 98.87%. It was observed that with a long exposure in high AQI environment, the poor air quality reduced the oxygen exchange with a lowest SpO2 level of 93% in the bloodstream. Conversely, in low AQI environments, SpO2 levels above 95% were recorded. The main originality of this paper a secured IoT system which uses AI to determine how AQI and heat index affect SpO2 levels in the blood stream.
T. P. Fowdur +10International Journal of Pervasive Computing and Communications
Scientific machine learning benchmarks rank methods by accuracy and record nothing about what that accuracy cost. No submission to the Matbench formationenergy task reports a training time, so claims about compute parsimony cannot be checked against the leaderboard at all. We introduce a compute-accounting protocol that reports featurization, descriptor selection, and training cost separately and charges a language model for its own inference, then use it to scrutinise a proposal of exactly the kind it was designed to test: that a small language model’s embedded domain knowledge can replace data-driven feature selection. Magpie composition descriptors form a closed grid of 22 element properties crossed with 6 aggregation statistics, so we ask locally served 4B and 8B models to choose 16 of exactly 132 named features, having seen no data and no labels, and evaluate every selection on the official five-fold splits of matbench_mp_e_form (132,752 crystals). The models are statistically indistinguishable from random draws on mean error (0.1798 against 0.1822 eV/atom, p = 0.64), and both a zerocost expert prior (0.1561) and a 7.2-second supervised selector (0.1466) beat every model-derived set. They do, however, cut the variance of one-shot selection by a factor of 4.4 (p = 0.0098), an effect that replicates under compositional extrapolation. We further show that the 4B model’s apparently superior stability is an artifact of prompt ordering. Everything ran on one laptop, CPU only. A compute column belongs on scientific ML leaderboards; without one it is easy to mistake a method that beats a weak baseline for one worth its price.
The proliferation of Internet of Things (IoT) devices has surged due to continuous advancements in interconnected computing and the emergence of novel network technologies. Safeguarding IoT networks necessitates the deployment of intrusion detection systems (IDSs). However, designing an IDS that achieves high accuracy with minimal false alerts is challenging due to the diversity of attacks and the issue of class imbalance. To address the problem of imbalanced samples in IoT environments, many researchers focus on parameter optimization of machine learning (ML) algorithms, feature selection (FS), and sampling techniques. However, these approaches often require significant time, computational resources, and may lead to data loss. This study proposes the cascading of ML techniques as a novel approach to overcome these limitations. A series of ML methodologies are employed to generate intermediate datasets, aiming to tackle the complexities posed by imbalanced data distributions. Experimental evaluation demonstrates that the proposed cascading method yields promising results when applied to the Multi-Step Cyber-Attack (MSCA) standard IDS dataset. The experimental results showed that the best Single-Level Cascading Architecture achieved 99.82% accuracy, while the Two-Level Cascading Architecture reached 99.99% accuracy. Notably, it effectively handles low-instance data associated with Web_Crawling and ICMP_Flood attacks, highlighting that many existing approaches do not comprehensively address class imbalance. The cascading-based proposed approach achieves a favourable balance between effectiveness and efficiency.
D. K. K. Reddy +60International Journal of Innovation and Technology Management (IJITM)
Machine-learning intrusion detectors commonly report strong performance within one benchmark, but deployment requires transport across traffic environments and realistic target prevalence. This study used three public harmonized NetFlow datasets: NF-UNSW-NB15, NF-ToN-IoT, and NF-BoT-IoT. Their archive attack prevalences were 4.46%, 80.40%, and 97.69%, whereas the balanced analytical samples had 40.23%, 50.00%, and 86.66%. Across the original crossed experiment, mean within-domain AUROC was 0.9773 versus 0.5445 across domains. Removing endpoint-oriented fields reduced uncalibrated cross-domain AUROC from 0.5881 to 0.4990, and source Platt scaling worsened target Brier loss. In a separate repeated evaluation using three uniform 100,000-flow samples at each target’s natural archive prevalence, full-flow models achieved mean AUROC 0.5880, AUPRC 0.6406, F1 0.4348, and Brier loss 0.3398. A threshold fixed at the source-negative 99.5th percentile nevertheless alerted on 36.2% of target flows. Endpoint reduction produced near-chance AUROC (0.4996) and lower F1 (0.3733). High within-benchmark scores therefore did not establish portable ranking, probability quality, or manageable alert rates.
This study systematically examines the evolution of Business Process Reengineering (BPR) research and its integration with business model innovation from 2015 to 2025. It aims to analyze how BPR supports organizational transformation, strengthens digital capabilities, and creates value through business model operationalization. A Systematic Literature Review (SLR) was conducted on 197 peer-reviewed articles indexed in Scopus using the keywords “business process reengineering”, “business process”, “reengineering” and “business model”. The review followed the PRISMA framework, while Biblioshiny and VOSviewer were employed for bibliometric analysis and visualization. The findings reveal four stages in the evolution of BPR research. The first stage (2015–2017) emphasized information technology integration and project management to improve process efficiency. The second stage (2018–2020) focused on technology-driven applications, including the Internet of Things (IoT) and supply chain optimization. The third stage (2021–2022) highlighted blockchain, digital twins, and sector-specific innovations in public services and banking. The latest stage (2023–2025) is characterized by AI and machine learning-enabled BPR, supporting intelligent process redesign and customer-centric transformation within the Industry 4.0 context. This study contributes by systematically linking BPR evolution with business model operationalization frameworks, including SDBMOM, ARPM, and the Compass Method, demonstrating how process transformation drives strategic value creation. The findings also show BPR’s contribution to the UN Sustainable Development Goals (SDGs) 8, 9, and 12 through enhanced productivity, innovation, and sustainable production. Future research should examine long-term organizational impacts and cross-sector implementation of AI-enabled BPR.
Roby Syaiful Ubed +30Aptisi Transactions On Technopreneurship (ATT)
Multifunctional self-powered fibers demonstrate significant potential for applications in wearable flexible electronics, human-machine interfaces, and Internet of Things (IoT) systems. A critical challenge in this field is achieving the effective integration and versatile application of various functional fibers. This study presents a novel multifunctional coaxial energy fiber capable of simultaneous energy harvesting, storage, and utilization. The fiber features a coaxial architecture that integrates an inner fiber-shaped zinc-ion supercapacitor (F-ZnSC) for energy storage and an outer spiral-yarn triboelectric nanogenerator (TENG) for energy harvesting and self-powered pressure sensor. The F-ZnSC comprises MXene-modified spiral yarn electrodes, a zinc wire anode, and a Gelatin/ZnSO₄ gel electrolyte, achieving a high specific capacitance of 455 mF cm⁻¹ along with excellent rate capability and cycling stability (e.g., ~96.6% capacitance retention after 5,000 cycles). The outer spiral-yarn TENG exhibits a high pressure sensitivity of 8 V kPa⁻¹, enabling effective and real-time monitoring of finger motions. Combining with a deep learning algorithm, the system recognizes five distinct hand gestures with an accuracy of 96.25%, demonstrating its utility in advanced game control and human-machine interaction. Furthermore, the encapsulation layer shared by the TENG and the F-ZnSC forms an additional contact-separation mode energy harvester. Ten such devices connected in parallel yield an output power of 177.1 μW, sufficient to power small electronics such as watches and calculators. This work highlights the promise of the coaxial energy fiber as a versatile platform for adaptive wearable energy systems, self-powered interfaces, and intelligent sensing.
Liang Wei +110International Journal of Extreme Manufacturing
Mixture-of-Experts (MoE) inference with expert parallelism (EP) relies on All-to-All communication, making computation-communication overlap strategies critical for achieving high performance. However, no strategy is universally optimal. Across 103 production configurations, varying input lengths, and four hardware platforms, we observe that the fastest strategy shifts based on model shape, EP degree, input length, and hardware. Since no strategy dominates more than 80.6% of configurations, configuration-aware selection is necessary. In this work, we propose OverlapAdvisor, which models overlap stages using two granularities to capture computation-communication dependencies. OverlapAdvisor builds a unified performance model, accounting for deviations from peak compute, memory, and communication performance across workloads and hardware. This model enables launch-time, configuration-aware strategy selection within two serving engines. We conduct experiments on four MoE models (30B-235B) against three baselines, utilizing SGLang and vLLM. At the kernel level, OverlapAdvisor achieves 1.16x average and 1.59x maximum speedups, with a prediction MAPE of 3.3%-15.9%. In SGLang and vLLM, it improves end-to-end throughput up to 31.7%. Its granularity-guided optimizations further achieve median speedups of 1.10x for DeepEP-v1 and 1.22x for FlashMoE.
AI systems must often maintain bounded memory of unbounded interaction histories. However, optimizing the memory representation, and its updates, for downstream task utility is difficult for standard reinforcement learning (RL) due to severe credit assignment bottlenecks induced by sparse, delayed rewards. We introduce MaxIM (Maximally Informative Incremental Memory), a framework that formulates incremental summarization as a capacity-constrained, information-theoretic reward-shaping problem. Grounded in value suboptimality bounds, we show that bounding sequential information loss motivates maximizing the predictive log-likelihood of future, task-relevant targets, a variational lower bound on predictive sufficiency. We introduce a recursive consistency condition to ensure summaries are grounded by maximizing mutual information (MI) with the observed history. We mitigate credit assignment issues with a parameterized asymmetric critic that computes step-wise variational MI bounds for dense reward shaping. Empirical evaluation on long-horizon scientific reading and multi-turn dialogue benchmarks shows that MaxIM outperforms RL, supervised fine-tuning, and prompt-focused baselines on factual grounding, comprehensive autorater metrics, and downstream task utility across strict token budgets and extended horizons, without the need for expensive human preference labels.