Runtime Adaptation Research Articles

Self-adaptive fault diagnosis for unseen working conditions based on digital twins and domain generalization

In recent years, intelligent fault diagnosis based on domain adaptation has been used to address domain shifts in cyber–physical systems; however, the need for acquiring target data sufficiently limits their applicability to unseen working conditions. To overcome such limitations, domain generalization techniques have been introduced to enhance the capacity of fault diagnostic models to operate under unseen working conditions. Nevertheless, existing approaches assume access to extensive labeled training data from various source domains, posing challenges in real-world engineering scenarios due to resource constraints. Moreover, the absence of a mechanism for updating diagnostic models over time calls for the exploration of self-adaptive generalized diagnosis models that are capable of autonomous reconfiguration in response to new unseen working conditions. In such a context, this paper proposes a self-adaptive fault diagnosis system that combines several paradigms, namely Monitor-Analyze-Plan-Execute over a shared Knowledge (MAPE-K), Domain Generalization Network Models (DGNMs), and Digital Twins (DT). The MAPE-K loop enables run-time adaptation to dynamic industrial environments without human intervention. To address the scarcity of labeled training data, digital twins are used to generate supplementary data and continuously tune parameters to reflect the dynamics of new unseen working conditions. DGNM incorporates adversarial learning and a domain-based discrepancy metric to enhance feature diversity and generalization. The introduction of multi-domain data augmentation enhances feature diversity and facilitates learning correlations among multiple domains, ultimately improving the generalization of feature representations. The proposed fault diagnosis system has been evaluated on three publicly available rotating machinery datasets to demonstrate its higher performance in cross-work operation and cross-machine tasks compared to other state-of-the-art methods.

CARIn: Constraint-Aware and Responsive Inference on Heterogeneous Devices for Single- and Multi-DNN Workloads

The relentless expansion of deep learning (DL) applications in recent years has prompted a pivotal shift towards on-device execution, driven by the urgent need for real-time processing, heightened privacy concerns, and reduced latency across diverse domains. This paper addresses the challenges inherent in optimising the execution of deep neural networks (DNNs) on mobile devices, with a focus on device heterogeneity, multi-DNN execution, and dynamic runtime adaptation. We introduce CARIn , a novel framework designed for the optimised deployment of both single- and multi-DNN applications under user-defined service-level objectives (SLOs). Leveraging an expressive multi-objective optimisation (MOO) framework and a runtime-aware sorting and search algorithm ( RASS ) as the MOO solver, CARIn facilitates efficient adaptation to dynamic conditions while addressing resource contention issues associated with multi-DNN execution. Notably, RASS generates a set of configurations, anticipating subsequent runtime adaptation, ensuring rapid, low-overhead adjustments in response to environmental fluctuations. Extensive evaluation across diverse tasks, including text classification, scene recognition, and face analysis, showcases the versatility of CARIn across various model architectures, such as Convolutional Neural Networks (CNNs) and Transformers, and realistic use cases. We observe a substantial enhancement in the fair treatment of the problem’s objectives, reaching 1.92 × when compared to single-model designs, and up to 10.69 × in contrast to the state-of-the-art OODIn framework. Additionally, we achieve a significant gain of up to 4.06 × over hardware-unaware designs in multi-DNN applications. Finally, our framework sustains its performance while effectively eliminating the time overhead associated with identifying the optimal design in response to environmental challenges.

Enhanced read resolution in reconfigurable memristive synapses for Spiking Neural Networks

The synapse is a key element circuit in any memristor-based neuromorphic computing system. A memristor is a two-terminal analog memory device. Memristive synapses suffer from various challenges including high voltage, SET or RESET failure, and READ margin issues that can degrade the distinguishability of stored weights. Enhancing READ resolution is very important to improving the reliability of memristive synapses. Usually, the READ resolution is very small for a memristive synapse with a 4-bit data precision. This work considers a step-by-step analysis to enhance the READ current resolution or the read current difference between two resistance levels for a current-controlled memristor-based synapse. An empirical model is used to characterize the HfO2\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$${\\hbox {HfO}}_{2}$$\\end{document} based memristive device. 1st\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$1\ extrm{st}$$\\end{document} and 2nd\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$2\ extrm{nd}$$\\end{document} stage device of our proposed synapse design can be scaled to enhance the READ current margin up to ∼\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\\sim$$\\end{document} 4.3×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes$$\\end{document} and ∼\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\\sim$$\\end{document} 21%, respectively. Moreover, READ current resolution can be enhanced with run-time adaptation techniques such as READ voltage scaling and body biasing. The READ voltage scaling and body biasing can improve the READ current resolution by about 46% and 15%, respectively. TENNLab’s neuromorphic computing framework is leveraged to evaluate the effect of READ current resolution on classification, control, and reservoir computing applications. Higher READ current resolution shows better accuracy than lower resolution even when facing different levels of read noise.

A Survey on Modeling Languages for Applications Hosted on Cloud-Edge Computing Environments

In the field of edge-cloud computing environments, there is a continuous quest for new and simplified methods to automate the deployment and runtime adaptation to application lifecycle changes. Towards that end, cloud providers promote their own service description languages to describe deployment and adaptation processes, whereas application developers opt for cloud-agnostic open standards capable of modeling applications. However, not all open standards are able to capture concepts that relate to the adaptation of the underlying computing environment to changes in the application lifecycle. In our quest for a formal approach to encapsulate these concepts, this study presents various Cloud Modeling Languages (CMLs). In this study, when referring to CMLs, we are discussing service description languages, domain-specific languages, and open standards. The output of this study is a review that performs a classification on CMLs based on their effectiveness in describing deployment and adaptation of applications in both cloud and edge environments. According to our findings, approximately 90.9% of the examined languages offer support for deployment descriptions overall. In contrast, only around 27.2% of examined languages allow developers the choice to specify whether their application components should be deployed on the edge or in a cloud environment. Regarding runtime adaptation descriptions, approximately 54.5% of the languages provide support in general.

A Progressive Subnetwork Searching Framework for Dynamic Inference.

Deep neural network (DNN) model compression is a popular and important optimization method for efficient and fast hardware acceleration. However, the compressed model is usually fixed, without the capability to tune the computing complexity (i.e., latency in hardware) on-the-fly, depending on dynamic latency requirements, workloads, and computing hardware resource allocation. To address this challenge, dynamic DNN with run-time adaption of computing structures has been constructed through training with a cross-entropy objective function consisting of multiple subnets sampled from the supernet. Our investigations in this work show that the performance of dynamic inference highly relies on the quality of subnet sampling. To construct a dynamic DNN with multiple high-quality subnets, we propose a progressive subnetwork searching framework, which is embedded with several proposed new techniques, including trainable noise ranking, channel-group sampling, selective fine-tuning, and subnet filtering. Our proposed framework empowers the target dynamic DNN with higher accuracy for all the subnets compared with prior works on both the Canadian Institute for Advanced Research dataset with 10 classes (CIFAR-10) and ImageNet datasets. Specifically, compared with United States-Neural Network (US-NN), our method achieves 0.9% average accuracy gain for Alexnet, 2.5% for ResNet18, 1.1% for Visual Geometry Group (VGG)11, and 0.58% for MobileNetv1, on the ImageNet dataset, respectively. Moreover, to demonstrate run-time tuning of computing latency of dynamic DNN in real computing system, we have deployed our constructed dynamic networks into Nvidia Titan graphics processing unit (GPU) and Intel Xeon central processing unit (CPU), showing great improvement over prior works. The code is available at https://github.com/ASU-ESIC-FAN-Lab/Dynamic-inference.

Deep Reinforcement Learning for Automatic Run-Time Adaptation of UWB PHY Radio Settings

Deep Reinforcement Learning for Automatic Run-Time Adaptation of UWB PHY Radio Settings

Runtime Adaptation Framework for Fulfilling Availability and Continuity Requirements of Network Services

The Network Function Virtualization (NFV) framework is an enabler for the automation of Network Service (NS) management. In the context of NFV, an NS is realized by interconnecting Virtual Network Functions (VNF) using Virtual Links (VL). Availability and continuity are among the important characteristics of an NS. These characteristics depend on the availability of the VNFs and VLs composing the NS, which are usually selected at NS design time. VNFs and VLs utilize the resources of the underlying infrastructure, and their availability (partially) depends on the availability of these resources. To design an NS to fulfill availability and continuity requirements, the availability required from the resources is constrained at design time. However, the characteristics of these resources may change at runtime due to the dynamicity of NFV infrastructure. Thus, impacting the availability of the VNFs and the VLs, which in turn may impact the availability and continuity of the NS. To fulfill these requirements at runtime despite the changes in the infrastructure, the NS should be adapted. In this paper, we propose a framework for the runtime adaptation of NSs that reacts to changes and adapts the NS configuration so that it can fulfill its availability and continuity requirements during the NS lifetime. We also propose a method to develop machine learning models that are used within the framework to determine the required adjustments at runtime. We implemented the proposed framework, the method for developing the machine learning models, a testbed, and NSs to assess the feasibility and validity of our approach through experiments.

Exploiting Structure in Regular Expression Queries

Regular expression, or regex, is widely used to extract critical information from a large corpus of formatted text by finding patterns of interest. In tasks like log processing, the speed of regex matching is crucial. Data scientists and developers regularly use regex libraries that implement optimized regular expression matching using modern automata theory. However, computing state transitions in the underlying regex evaluation engine can be inefficient when a regex query contains a multitude of string literals. This inefficiency is further exasperated when analyzing large data volumes. This paper presents BLARE, Blazingly Fast Regular Expression, a regular expression matching framework that is inspired by the mechanisms that are used in database engines, which use a declarative framework to explore multiple equivalent execution plans, all of which produce the correct final result. Similarly, BLARE decomposes a regex into multiple regex and string components and then creates evaluation strategies in which the components can be evaluated in an order that is not strictly a left-to-right translation of the input regex query. Rather than using a cost-based optimization approach, BLARE uses an adaptive runtime strategy based on a multi-armed bandit approach to find an efficient execution plan. BLARE is also modular and can be built on top of any existing regex library. We implemented BLARE on four commonly used regex libraries, RE2, PCRE2, Boost Regex, and ICU Regex, and evaluated it using two production workloads and one open-source workload. BLARE was 1.6× to 3.7× faster than RE2 and 3.4× to 7.9× faster than Boost Regex. PCRE2 did not finish on one of the workloads, but on the remaining two workloads, BLARE improved the performance of PCRE2 by 3.1× to over 100×. For the open-source dataset, BLARE provided a speed up of 61.7× for ICU Regex. BLARE code is publicly available at https://github.com/mush-zhang/Blare.

Modeling variability in self-adapting robotic systems

Autonomous robots operating in everyday environments, such as hospitals, private houses, and public roads, are context-aware self-adaptive systems, i.e. they exploit knowledge about their resources and the environment to trigger runtime adaptation, so that they exhibit a behavior adequate to the current context. For these systems, context-aware self-adaptation requires to design the robot control application as a dynamically reconfigurable software architecture and to specify the adaptation logic for reconfiguring its variable aspects (e.g. the modules that implement various obstacle detection algorithms or control different distance sensors) according to specific criteria (e.g. enhancing robustness against variable illumination conditions). Despite self-adaptation is an intrinsic capability of autonomous robots, ad-hoc approaches are used in practice to design reconfigurable robot architectures. In order to enhance system maintainability, the control logic and the adaptation logic should be loosely coupled. For this purpose, the adaptation logic should be defined against an explicit representation of software variability in the robot control architecture. In this paper we propose a modeling approach, which consists in explicitly representing robot software variability with the MARTE::ARM-Variability metamodel, which has been designed as an extension of the UML MARTE profile. We evaluate the applicability of the proposed approach by exemplifying the software architecture design of a robot navigation framework and by analyzing the support provided by the ROS infrastructure for runtime reconfiguration of its variable aspects.

Testudo: Collaborative Intelligence for Latency-Critical Autonomous Systems

Edge computing is to be widely adopted for autonomous systems (AS) applications as compute-intensive processing tasks can be offloaded to compute-capable servers located at the edge of the network infrastructure. Given the critical nature of numerous AS applications, their tasks are mostly governed by strict execution deadlines to alleviate any safety concerns from delayed responses. Although wireless link uncertainty has prompted recent works to designate redundant local execution as an offloading fail-safe to ensure these deadlines are met, frequent invocation of such fail-safe mechanisms can potentially undermine the extent of performance gains from offloading. In this paper, we thoroughly analyze how redundant execution overheads can influence the overall performance. Then, we present Testudo, a methodology to optimize the energy consumption for latency-sensitive AS applications employing collaborative edge computing. Primarily, our methodology encompasses two main stages: (i) Designing processing pipelines supporting optimal offloading points and fail-safe integration using modular design techniques, and (ii) Developing a context-aware adaptive runtime solution based on Deep Reinforcement Learning to adapt the mode of operation according to the wireless network status. Our experiments for end-to-end control and object detection use-cases have shown that Testudo achieved energy gains reaching up to 31% and 13.4% (15.9% and 5.3% on average) for the former and latter, respectively, while incurring little-to-no degradation in prediction scores (<1% change) from state-of-the-art strategies.

Exploiting the Common Case When Accelerating Input-Dependent Stream Processing by FPGA

FPGAs have traditionally been successful in accelerating stream processing applications where the amount and type of work performed on each record&#x2014;e.g., image, packet&#x2014;do not depend on the record&#x0027;s contents. On the other hand, accelerating &#x2018;input-dependent&#x2019; stream processing on FPGAs presents a much more challenging problem where different records in the stream can require widely different operations. It is inefficient and unnecessary to support all operations at the same throughput when the distributions of the operations are skewed. In this paper, we examine the application of the &#x201C;make the common case fast&#x201D; strategy to efficiently accelerate &#x2018;input-dependent&#x2019; stream processing on FPGAs. In particular, we study the use of <i>fast-slow path</i> and <i>early-exit</i> techniques in the design of an FPGA-accelerated network intrusion prevention system (IPS). To avoid overfitting when common-case behavior is varied, we further examine <i>compile-time re-tuning</i> and <i>runtime adaptation</i> techniques. A quantitative analysis shows that fast-slow path and early-exit techniques can save an order of magnitude of resources compared to a common-case unaware IPS design. Compile-time re-tuning to specific conditions further achieves 30&#x0025; &#x2013; 94&#x0025; BRAM savings relative to a generalized design. Adding runtime adaptation improves the zero-loss throughput by 1.43 &#x2013; 2.75 &#x00D7; compared to a fixed design.

Adaptation of Parallel SaaS to Heterogeneous Co-Located Cloud Resources

Cloud computing has received increasing attention due to its promise of delivering on-demand, scalable, and virtually unlimited resources. However, heterogeneity or co-location of virtual cloud resources can cause severe degradation of the efficiency of parallel computations because of a priori unknown application-specific performance metrics, load imbalance, and limitations of memory bandwidth. This paper presents the runtime adaptation of parallel discrete element method (DEM) Software as a Service (SaaS) to heterogeneous or co-located resources of the OpenStack cloud. The computational workload is adapted by using weighted repartitioning and runtime measured performance of parallel computations on Docker containers. The high improvement in performance up to 48.7% of the execution time is achieved, applying the runtime adapted repartitioning when the load imbalance is high enough. The low load imbalance leads to the close values of computational load, when small variations in the system load and performance can cause oscillations in subsets of particles. Memory stress tests cause heterogeneity of non-isolated containers, which reduces the performance of memory bandwidth bound DEM SaaS on the co-located resources. The runtime adapted repartitioning handles the constant and periodically variable performance of non-isolated containers and decreases the total execution time of DEM SaaS.

Software runtime monitoring with adaptive sampling rate to collect representative samples of execution traces

Monitoring software systems at runtime is key for understanding workloads, debugging, and self-adaptation. It typically involves collecting and storing observable software data, which can be analyzed online or offline. Despite the usefulness of collecting system data, it may significantly impact the system execution by delaying response times and competing with system resources. The typical approach to cope with this is to filter portions of the system to be monitored and to sample data. Although these approaches are a step towards achieving a desired trade-off between the amount of collected information and the impact on the system performance, they focus on collecting data of a particular type or may capture a sample that does not correspond to the actual system behavior. In response, we propose an adaptive runtime monitoring process to dynamically adapt the sampling rate while monitoring software systems. It includes algorithms with statistical foundations to improve the representativeness of collected samples without compromising the system performance. Our evaluation targets five applications of a widely used benchmark. It shows that the error (RMSE) of the samples collected with our approach is 9%–54% lower than the main alternative strategy (sampling rate inversely proportional to the throughput), with 1%–6% higher performance impact.

Computer Vision on the Edge to Reduce Network Bandwidth Consumption and Computing Resources in Multi-view 3D Industrial Inspection without Hidden Surfaces

Industrial inspection industry requires high precision, fast and reliable systems, where images play a central role. These systems are composed by several hardware and also cyber-physical componentes where complexity increases when multiple heterogeneous sensor inputs are combined. Our 3D industrial inspection scanner is able to reconstruct complete objects without occlusion with use of multiple sensors and actuators using a complex software architecture. Our system allows increasing the throughput by removing the bottleneck network issue, decreasing network data transfer using a new edge systems architecture that segments and optimizes image transferring. Also, this work presents the results of applying technology developed during the FitOptiVis European ECSEL project. FitOptiVis will provide a reference architecture supporting composability built on suitable component abstractions and embedded sensing, actuation and processing devices adhering to those abstractions. The reference architecture will support design portability, on-line multi-objective quality and resource management and run-time adaptation guaranteeing system constraints and requirements based on platform virtualization. The FitOptiVis project will be applied to design the new architecture of the new edge components and develop the runtime system monitoring.

ActivFORMS: A Formally Founded Model-based Approach to Engineer Self-adaptive Systems

Self-adaptation equips a computing system with a feedback loop that enables it to deal with change caused by uncertainties during operation, such as changing availability of resources and fluctuating workloads. To ensure that the system complies with the adaptation goals, recent research suggests the use of formal techniques at runtime. Yet, existing approaches have three limitations that affect their practical applicability: (i) they ignore correctness of the behavior of the feedback loop, (ii) they rely on exhaustive verification at runtime to select adaptation options to realize the adaptation goals, which is time- and resource-demanding, and (iii) they provide limited or no support for changing adaptation goals at runtime. To tackle these shortcomings, we present ActivFORMS (Active FORmal Models for Self-adaptation). ActivFORMS contributes an end-to-end approach for engineering self-adaptive systems, spanning four main stages of the life cycle of a feedback loop: design, deployment, runtime adaptation, and evolution. We also present ActivFORMS-ta, a tool-supported instance of ActivFORMS that leverages timed automata models and statistical model checking at runtime. We validate the research results using an IoT application for building security monitoring that is deployed in Leuven. The experimental results demonstrate that ActivFORMS supports correctness of the behavior of the feedback loop, achieves the adaptation goals in an efficient way, and supports changing adaptation goals at runtime.

Integrated extreme gradient boost with c4.5 classifier for high level synthesis in very large scale integration circuits

High-level synthesis (HLS) is utilized for high-performance and energy-efficient heterogeneous systems designing. HLS is assist in field-programmable gate array circuits designing where hardware implementations are refined and replaced in target device. However, the power-process-voltage-temperature-delay (PPVTD) variation in VLSI circuits undergoes many problems and reduced the performance. In order to address these problems, C4.5 with eXtreme Gradient Boosting Classification based High Level Synthesis (C4.5-XGBCHLS) Method is designed for afford better runtime adaptability (RA) with minimal error rate. VLSI circuits are designed using the behavioral input and results are measured at running condition. When VLSI circuit’s results get reduced, the language description of the circuit is considered as an input. Then, compilation process convert high level specification into Intermediate Representation (IR) in control/data flow graph (CDFG). CDFG computes data and control dependencies among operations. eXtreme Gradient Boosting (XGBoost) Classifier is exploited in C4.5-XGBCHLS method to classify the error causing functional unit (FU) with minimal error rate. XGBoost Classifier exploited C4.5 decision tree as base classifier to enhance classification of error causing FU in VLSI circuits. After that, FU gets allocated in place of error causing FU from functional library based on the design objectives and PPVTD variations. Finally, operation scheduling and binding process is executed for register transfer level (RTL) generation to form VLSI circuits with improved RA. The simulation results shows that the C4.5-XGBCHLS method enhances the performance of functional unit selection accuracy (FUSA) with minimal error rate (ER) and circuit adaptability time (CAT).

Efficient Difference Analysis of Guaranteeable Requirements for Fault-tolerant Self-adaptation

Modern systems suffer system faults in both hardware and software. Requirement degradation is a widely applied redundant-design approach to deal with system fault by degrading or disabling (non-critical) requirements. However, due to the environment's unpredictability, it is unrealistic for engineers to prepare such redundant designs for unforeseen and unknown faults in advance. Requirement-aware self-adaptive systems have been investigated to address this challenge. Specifically, such a system can autonomously analyze which requirements are guaranteeable so that the requirement degradation can be determined automatically to satisfy the maximal requirements. The previous work has proposed an algorithm to recognize the guaranteeable requirements by analyzing a two-player game between the environment and the system. However, such an algorithm is not designed for the system fault, and the entire game must be re-analyzed from scratch, making it inefficient for runtime adaptation. In this paper, we propose an efficient difference analysis algorithm that reuses the previous analysis result to reduce the runtime computational overhead. Specifically, it carefully specifies which part of the result is reusable and only re-analyzes the part that may be affected. We evaluated the algorithm's effectiveness with four case studies, and the results indicate that an average of 46.5% computational time is reduced.

Test scenario generation for feature-based context-oriented software systems

Feature-based context-oriented programming reconciles ideas from context-oriented programming, feature modelling and dynamic software product lines. It offers a programming language, architecture, tools and methodology to develop software systems consisting of contexts and features that can become active at run-time to offer the most appropriate behaviour depending on the actual context of use. Due to their high run-time adaptivity, dedicated tool support to test such systems is needed. Building upon a pairwise combinatorial interaction testing approach from the domain of software product lines, we implement an algorithm to generate automatically a small set of relevant test scenarios, ordered to minimise the number of context activations between tests. We also explore how the generated scenarios can be enhanced incrementally when the software evolves, and how useful the proposed testing approach is in practice.

A psycho-educational intervention programme for parents with SGA foetuses supported by an adaptive mHealth system: design, proof of concept and usability assessment

BackgroundTechnology-based approaches during pregnancy can facilitate the self-reporting of emotional health issues and improve well-being. There is evidence to suggest that stress during pregnancy can affect the foetus and result in restricted growth and preterm birth. Although a number of mobile health (mHealth) approaches are designed to monitor pregnancy and provide information about a specific aspect, no proposal specifically addresses the interventions in parents at risk of having small-for-gestational-age (SGA) or premature babies. Very few studies, however, follow any design and usability guidelines which aim to ensure end-user satisfaction when using these systems.ResultsWe have developed an interactive, adaptable mHealth system to support a psycho-educational intervention programme for parents with SGA foetuses. The relevant results include a metamodel to support the task of modelling current or new intervention programmes, an mHealth system model with runtime adaptation to changes in the programme, the design of a usable app (called VivEmbarazo) and an architectural design and prototype implementation. The developed mHealth system has also enabled us to conduct a proof of concept based on the use of the mHealth systems and this includes data analysis and assesses usability and acceptance.ConclusionsThe proof of concept confirms that parents are satisfied and that they are enthusiastic about the mHealth-supported intervention programme. It helps to technically validate the results obtained in the other stages relating to the development of the solution. The data analysis resulting from the proof of concept confirms that the stress experienced by parents who followed the mHealth-supported intervention programme was significantly lower than among those who did not follow it. This implies an improvement in the emotional health not only of the parents but also of their child. In fact, the babies of couples who followed the mHealth-supported programme weigh more than the babies of couples under traditional care. In terms of user acceptance and usability, the analysis confirms that mothers place greater value on the app design, usefulness and ease of use and are generally more satisfied than their partners. Although these results are promising in comparison with more traditional and other more recent technology-based approaches.

Toward the Predictability of Dynamic Real-Time DNN Inference

Deep neural networks (DNNs) have been widely used in many cyber–physical systems (CPSs). However, it is still a challenging work to deploy DNNs in real-time systems. In particular, the execution time of DNN inference must be predictable, s.t. it could be known whether the runtime inference can complete within a required timing constraint. Moreover, the timing constraints may change dynamically with the runtime environment in many embedded applications, such as autonomous cars. A possible way to meet such dynamic real-time requirements is to execute different subnetworks of a DNN at runtime. However, improper construction of subnetworks may not only introduce unpredictable inference time, s.t. the real-timing constraints could be violated unexpectedly, but also has poor compatibility with the well-optimized machine learning framework (e.g., TensorFlow). In this article, we study the predictability when executing different subnetworks of a DNN. In particular, we present a featurewise runtime adaptation framework for DNN inference, which is implemented and validated on NVIDIA Jetson TX2 and Nano with TensorFlow. The experimental results show that our method can achieve predictable inference time in comparison with the state-of-the-art methods.