Falls are the second leading cause of unintentional injury deaths worldwide. While numerous wearable fall detection devices incorporating AI models have been developed, none of them are used successfully in a fall detection application running on commodity-based smartwatches in real time. The system misses some falls, and generates an annoying amount of False Positives for practical use. We have investigated and experimented with an LSTM model for fall detection on a smartwatch. Even though the LSTM model has high accuracy during offline testing, the good performance of offline LSTM models cannot be translated to the equivalence of real-time performance. Transformers, on the other hand, can learn long-sequence data and patterns intrinsic to the data due to their self-attention mechanism. This paper compares three variants of LSTM and two variants of Transformer models for learning fall patterns. We trained all models using fall and activity data from three datasets, and the real-time testing of the model was performed using the SmartFall App. Our findings showed that in the offline training, the CNN-LSTM model was better than the Transformer model for all the datasets. However, the Transformer is a preferable choice for deployment in real-time fall detection applications.

The widespread adoption of smartphones and smartwatches has enabled non-intrusive fall detection through built-in sensors and on-device computation. While these devices are widely used by older adults, existing systems still struggle to accurately detect soft falls in real-world settings. There is a notable drop in performance when fall-detection models trained offline on labeled accelerometer data are deployed and tested in real-world conditions using streaming, real-time data. To address this, our experimental study investigates whether incorporating additional sensor modalities, specifically gyroscope data with accelerometer data from wrist and hip locations, can help bridge this performance gap. Through systematic experimentation, we demonstrated that combining accelerometer data from the hip and the wrist yields a model capable of achieving an F1-score of 88% using a Transformer-based neural network in offline evaluation, which is an improvement of 8% over a model trained solely on wrist accelerometer data. However, when it is deployed in an uncontrolled home environment with streaming real-time data, this model produced a high number of false positives. To address this, we retrained the model using feedback data that comprised both false positives and true positives and was collected from ten participants during real-time testing. This refinement yielded an F1-sore of 92% and significantly reduced false positives while maintaining comparable accuracy in detecting true falls in real-world settings. Furthermore, we demonstrated that the improved model generalizes well to older adults’ movement patterns, with minimal false-positive detections.

We present an edge-cloud collaborative personalized fall detection pipeline called P-Fall. A personalized fall detection model requires real-time adaptation of a pre-trained model using real-time feedback data provided by the user. We, herein, highlight the design of the software architecture for a collaborative framework, the smart-watch's UI for the ease of collecting a user's feedback data, and the automation of the personalization process.

Android apps rely on application programming interfaces (APIs) to access various functionalities of Android devices. These APIs however are regularly updated to incorporatenew features while the old APIs get deprecated. Even though the importance of updating deprecated API usages with the recommended replacement APIs has been widely recognized, it is non-trivial to update the deprecated API usages. Therefore, the usages of deprecated APIs linger in Android apps and cause compatibility issues in practice. This paper introduces GUPPY, an automated approach that utilizes large language models (LLMs) to update Android deprecated API usages. By employing carefully crafted Chain-of-Thoughts prompts, GUPPY leverages GPT-4, one of the most powerful LLMs, to update deprecated-API usages, ensuring compatibility in both the old and new API levels. Additionally, GUPPY uses GPT-4 to generate tests, identify incorrect updates, and refine the API usage through an iterative process until the tests pass or a specified limit is reached. Our evaluation, conducted on 360 benchmark API usages from 20 deprecated APIs and an additional 156 deprecated API usages from the latest API levels 33 and 34, demonstrates GUPPY’s advantages over the state-of-the-art techniques.

Modern Internet of Things (IoT) systems increasingly rely on machine learning/deep learning models deployed across edge devices and cloud infrastructure. However, many real-world IoT systems require personalized models for each user or device, making scalable retraining, deployment, and real-time inference challenging. To address this, we propose a practical low-cost edge–cloud framework for concurrent personalization of AI models in IoT systems that can support users in a community-dwelling center. The personalization is achieved with a data-efficient machine learning retraining model (MODELXc) coupled with a layered software architecture that separates edge sensing, communication, cloud processing, and model management. First, retraining of AI model jobs runs as Kubernetes pods with pre-configured CPU and memory limits, and users are grouped into batches to prevent resource oversubscription during concurrent training. Second, edge devices communicate with the cloud using NATS.io request-reply messaging with binary-encoded payloads for low-latency communication. Third, a lifecycle pipeline handles versioned model storage, in-memory caching, and background synchronization. We evaluated this framework using two IoT applications: a wearable fall-detection system and a heart-rate-monitoring system. The second application is used to demonstrate the cross application portability of our infrastructure. Using the MODELXc personalization workflow, we executed 40 user-specific training jobs concurrently on a 40-logical-CPU server within one minute. We also demonstrated experimentally that a 40-CPU server can support personalization of 5000 virtual users in a 6–7 h period using a batch-wise processing strategy. Docker- and Kubernetes-based orchestration provided bounded per-job resource usage and resulted in a predictable system load compared with traditional background execution. For real-time inference, NATS.io with binary encoding and controlled throttling achieved a median latency of approximately 110–120 ms, compared with approximately 220 ms using the default without binary encoding.