In this paper, we investigate a hardware approach for on-device training and inference targeting fully quantized graph convolutional networks (GCNs). Our proposed solution leverages a specialized hardware accelerator consisting of a streaming architecture and adaptive fixed-point numeric precision. The accelerator offers scalable performance via a variable number of independent hardware threads and compute units per thread. During training, the architecture widens the data path in the backward pass to maintain the gradient accuracy needed for backpropagation. In contrast, during the forward pass, the accelerator narrows the data path to emulate the uncertainty introduced by the quantized parameters. We use the popular Planetoid datasets to benchmark the accelerator, achieving valid precisions extending down to 1-bit for weights and features and 2-bits for adjacency. The performance gains over the Pytorch optimized software solution show more than 2 orders of magnitude for inference and 1 order of magnitude for training. A comparison with previous GCN accelerators designed for inference-only mode and based on HPC (High Performance Computing) FPGA platforms shows competitive performance.

This paper introduces an innovative approach using deep learning for human identification utilizing millimeter-wave (mmWave) radar technology. Unlike conventional vision methods, our approach ensures privacy and accuracy in various indoor settings. Leveraging partial PointNet, Convolutional Neural Network (CNN), and Bi-directional Long Short-Term Memory (Bi-LSTM) network components, we propose a unique neural network architecture named MMIDNet, designed to directly process point cloud data from mmWave radar. Our system achieves an impressive identification accuracy of 92.4% for 12 individuals. The research encompasses data collection, system design, and evaluation, highlighting the potential of mmWave radar combined with deep learning for secure and efficient human identification in Internet of Things (IoT) applications.

Graph neural networks (GNNs) combine sparse and densedata compute requirements that are challenging to meet in resourceconstrained embedded hardware. In this paper, we investigate a dataflowof dataflows architecture that optimizes data access and processing element utilization. The architecture is described with high-level synthesisand offers multiple configuration options including varying the number ofindependent hardware threads, the interface data width and the numberof compute units per thread. Each hardware thread uses a fine-graineddataflow to stream words with a bit-width that depends on the network precision while a coarse-grained dataflow links the thread stagesstreaming partially-computed matrix tiles. The accelerator is mappedto the programmable logic of a Zynq Ultrascale device whose processing system runs Pytorch extended with PYNQ overlays. Results basedon the citation networks show a performance gain of up to 140x withmulti-threaded hardware configurations compared with the optimizedsoftware implementation available in Pytorch. The results also show competitive performance of the embedded hardware compared with otherhigh-performance state-of-the-art hardware accelerators.

In this paper, we present a dynamically reconfigurable hardware accelerator called FADES (Fused Architecture for DEnse and Sparse matrices). The FADES design offers multiple configuration options that trade off parallelism and complexity using a dataflow model to create four stages that read, compute, scale and write results. FADES is mapped to the programmable logic (PL) and integrated with the TensorFlow Lite inference engine running on the processing system (PS) of a heterogeneous SoC device. The accelerator is used to compute the tensor operations, while the dynamically reconfigurable approach can be used to switch precision between int8 and float modes. This dynamic reconfiguration enables better performance by allowing more cores to be mapped to the resource-constrained device and lower power consumption compared with supporting both arithmetic precisions simultaneously. We compare the proposed hardware with a high-performance systolic architecture for dense matrices obtaining 25% better performance in dense mode with half the DSP blocks in the same technology. In sparse mode, we show that the core can outperform dense mode even at low sparsity levels, and a single-core achieves up to 20x acceleration over the software-optimized NEON RUY library.

This paper presents EnergyAnalyzer, a code-level static analysis tool for estimating the energy consumption of embedded software based on statically predictable hardware events. The tool utilises techniques usually used for worst-case execution time (WCET) analysis together with bespoke energy models developed for two predictable architectures - the ARM Cortex-M0 and the Gaisler LEON3 - to perform energy usage analysis. EnergyAnalyzer has been applied in various use cases, such as selecting candidates for an optimised convolutional neural network, analysing the energy consumption of a camera pill prototype, and analysing the energy consumption of satellite communications software. The tool was developed as part of a larger project called TeamPlay, which aimed to provide a toolchain for developing embedded applications where energy properties are first-class citizens, allowing the developer to reflect directly on these properties at the source code level. The analysis capabilities of EnergyAnalyzer are validated across a large number of benchmarks for the two target architectures and the results show that the statically estimated energy consumption has, with a few exceptions, less than 1% difference compared to the underlying empirical energy models which have been validated on real hardware.

This paper investigates an indoor multiple human tracking andfall detection system based on the usage of multiple MillimeterWave radars from Texas Instruments. We propose a real-timesystem framework to merge the signals received from radars andtrack the position and body status of human objects. In order toguarantee the overall accuracy of our system, we develop novelstrategies such as dynamic DBSCAN clustering based on signalenergy levels and a possibility matrix for multiple object tracking. Our prototype system, which employs three radars placedon x-y-z surfaces, demonstrates higher accuracy than the solution in [1] (90%), with 98.5% and 98.2% accuracy in multiplehuman tracking and fall detection respectively. The accuracyreaches 99.7% for single human tracking.

High-precision time-to-digital converters (TDCs) are key components for controlling quantum systems and FPGAs have gained popularity for this task thanks to their low-cost and flexibility compared with Application Specific Integrated Circuits (ASICs). This paper investigates a novel FPGA-based TDC architecture that combines a wave union launcher and delay lines constructed with DSP blocks. The configuration achieves a 8.07ps RMS resolution on a low-cost Zynq FPGA with a power usage of only 0.628W. The low power consumption is achieved thanks to a combination of operating frequency and logic resource usage that are lower than other methods, such as multi-chain DSP based TDCs and multi-chain CARRY4 based TDCs

Energy modelling can enable energy-aware software development and assist the developer in meeting an application's energy budget. Although many energy models for embedded processors exist, most do not account for processor-specific config-urations, neither are they suitable for static energy consumption estimation. This paper introduces a set of comprehensive energy models for Arm's Cortex-M0 processor, ready to support energy-aware development of edge computing applications using either profiling- or static-analysis-based energy consumption estimation. We use a commercially representative physical platform together with a custom modified Instruction Set Simulator to obtain the physical data and system state markers used to generate the models. The models account for different processor configurations which all have a significant impact on the execution time and energy consumption of edge computing applications. Unlike existing works, which target a very limited set of applications, all developed models are generated and validated using a very wide range of benchmarks from a variety of emerging IoT application areas, including machine learning and have a prediction error of less than 5%.

Graph processing is an area that has received significant attention in recent years due to the substantial expansion in industries relying on data analytics. Alongside the vital role of finding relations in social networks, graph processing is also widely used in transportation to find optimal routes and biological networks to analyse sequences. The main bottleneck in graph processing is irregular memory accesses rather than computation intensity. Since computational intensity is not a driving factor, we propose a method to perform graph processing at the edge more efficiently. We believe current cloud computing solutions are still very costly and have latency issues. The results demonstrate the benefits of a dedicated sparse graph processing algorithm compared with dense graph processing when analysing data with low density. As graph datasets grow exponentially, traversal algorithms such as breadth-first search (BFS), fundamental to many graph processing applications and metrics, become more costly to compute. Our work focuses on reviewing other implementations of breadth-first search algorithms designed for low power systems and proposing our solution that utilises advanced enhancements to achieve a significant performance boost up to 9.2x better performance in terms of MTEPS compared to other state-of-the-art solutions with a power usage of 2.32W.

In this paper, we investigate the application of early-exit strategies to fully quantized neural networks, mapped to low-complexity FPGA SoC devices. The challenge of accuracy drop with low bitwidth quantized first convolutional layer and fully connected layers has been resolved. We apply an early-exit strategy to a network model that combines weights and activation with extremely low bitwidth and binary arithmetic precision based on the ImageNet dataset. We use entropy calculations to decide which branch of the early-exit network to take. The experiments show an improvement in inferred speed of $$1.52\times $$1.52×using an early-exit system, compared with using a single primary neural network, with a slight accuracy decrease of 1.64%.