High-level API Research Articles

Crabtree: Rust API Test Synthesis Guided by Coverage and Type

Rust type system constrains pointer operations, preventing bugs such as use-after-free. However, these constraints may be too strict for programming tasks such as implementing cyclic data structures. For such tasks, programmers can temporarily suspend checks using the unsafe keyword. Rust libraries wrap unsafe code blocks and expose higher-level APIs. They need to be extensively tested to uncover memory-safety bugs that can only be triggered by unexpected API call sequences or inputs. While prior works have attempted to automatically test Rust library APIs, they fail to test APIs with common Rust features, such as polymorphism, traits, and higher-order functions, or they have scalability issues and can only generate tests for a small number of combined APIs. We propose Crabtree, a testing tool for Rust library APIs that can automatically synthesize test cases with native support for Rust traits and higher-order functions. Our tool improves upon the test synthesis algorithms of prior works by combining synthesis and fuzzing through a coverage- and type-guided search algorithm that intelligently grows test programs and input corpus towards testing more code. To the best of our knowledge, our tool is the first to generate well-typed tests for libraries that make use of higher-order trait functions. Evaluation of Crabtree on 30 libraries found four previously unreported memory-safety bugs, all of which were accepted by the respective authors.

#2784 Deep learning algorithm predicts individual ultrafiltration trajectories for patients on automated peritoneal dialysis 12 weeks ahead

Abstract Background and Aims Adequate small solute clearance and ultrafiltration (UF) are the main requirements for fluid and salt homeostasis on peritoneal dialysis (PD). New automated peritoneal dialysis (APD) systems that allow remote patient monitoring in terms of PD treatment analysis have the potential to improve clinical outcomes. UF on APD although dependent on PD prescription, i.e. fill volumes and glucose concentration, exhibits substantial intra- and interindividual variation, even day-by-day. As conventional statistical methods are not able to assess these complex non-linear relationships adequately, we aimed to build a deep learning algorithm to predict ultrafiltration trajectories of individual patients 12 weeks ahead. Method Data on daily UF and PD prescriptions (i.e., glucose concentration, fill volumes) was extracted from the APD cycler management software (PD Link, Baxter, IL, USA) and patient charts at the Medical University of Vienna, for a secondary analysis of this cohort. The Keras high-level API for TensorFlow in R software (R Core Team 2023) was used to create a Long Short-Term Memory (LSTM) recurrent neural network based on historic prescription and gcUF data of 26 weeks (after the first 90 days of APD) to predict individual UF trajectories for the following 12 weeks. Results APD machine readouts from a total of 123 patients, with a mean time on PD of 117 (±73) days, were retrieved. The final recurrent neural network consisted of four LSTM layers with 64 cells each, sigmoid activation. The final model was fit using 30 epochs, 49 steps per epoch, and recurrent dropout to avoid overfitting. A 40-40-20% data split was used to train, validate, and test the model adequately. This deep learning algorithm was able to predict individual UF values, for each day of the upcoming 12 weeks, with an accuracy of at mean 201ml. Upon visual inspection, predicted individual UF trajectories smoothly resemble the overall day-by-day trajectory of the patient but fail to account for extreme spikes in either direction. Conclusion In conclusion, historic daily APD cycler and prescription data in coalescence with respective daily measurements of membrane function (i.e., gcUF) can be used to predict individual daily ultrafiltration values and trajectories of APD patients 12 weeks ahead using a deep learning algorithm. Therefore, continuous collection of PD prescription data and UF measurements may be used to monitor peritoneal membrane function of patients on APD and alert clinical teams upon detection of relevant changes of UF trajectories already 12 weeks ahead to facilitate early intervention. In contrast to current “screening” methods on PD, i.e., Peritoneal Equilibrium Test, these methods could reduce treatment burden.

Boosting general-purpose stream processing with reconfigurable hardware

Reconfigurable devices such as field-programmable gate arrays (FPGAs) offer flexible solutions to workload acceleration with high energy efficiency. Despite such a potential advantage, they often reveal hard to program by application programmers. High-level synthesis languages have been developed to provide higher-level abstractions, allowing the developers to define the FPGA behavior using an imperative programming approach based on C/C++ languages. However, such approaches still leave the developer with the responsibility to harness the low-level optimizations required to develop efficient FPGA programs. Along this line, this paper introduces FSPX, a framework helping programmers to develop FPGA-accelerated data stream processing (DSP) applications. The approach provides a high-level Python API to develop the data-flow graph of operators, which is automatically translated into an efficient Vitis source code targeting Xilinx devices. The execution of the bitstreams implementing two benchmark applications showcases the efficiency of using FPGAs for DSP workloads. In general, FSPX provides, with a reasonable time-to-solution, higher performance compared with state-of-the-art DSP frameworks.

Boosting RDataFrame performance with transparent bulk event processing

Boosting RDataFrame performance with transparent bulk event processing

Binary Classification of Diabetes in Pima Indian Dataset: A Deep Learning Perspective

Abstract: In this study, we develop into the application of deep learning methodologies for diabetes prediction utilizing the Pima Indian dataset. Employing Keras with Theano as the backend, we establish a binary classification model to effectively forecast the presence or absence of diabetes in individuals. Our research aims to enhance the precision and reliability of diabetes diagnosis, ultimately contributing to improved healthcare decision-making. Our investigation leverages Keras, a high-level neural networks API, in conjunction with Theano, to conduct binary classification on the Pima Indian diabetes dataset. Our study provides valuable insights into the field of medical data analysis, showcasing the effectiveness of deep learning techniques in advancing diagnostic tools for proactive healthcare management. Diabetes mellitus, a prevalent chronic disease globally, necessitates the development of a system for early type 2 diabetes mellitus (T2DM) diagnosis. Multiple machine learning and data mining techniques, including ANN, SVM, KNN, decision trees, and Extreme Learning Machines, have emerged and been employed as aids in diabetes detection. Consequently, we introduce Deep Learning, a subfield of machine learning, which can effectively handle smaller datasets through efficient data processing techniques. This paper presents an in-depth review of Diabetic Retinopathy, covering its features, causes, various ML models, DL models, challenges, comparisons, and future directions for early DR detection. Diabetes mellitus is a global health concern with a rapidly increasing prevalence. In this context, machine learning technologies prove invaluable for early disease identification and diagnosis. The focus of this study is to identify the most effective ML algorithm for diabetes prediction.

Deep style transfer to deal with the domain shift problem on spheroid segmentation

Spheroids are the most widely used 3D models for studying the effects of different micro-environmental characteristics on tumor behaviour, and for testing different preclinical and clinical treatments. Image analysis of spheroids is crucial to understand the formation and behaviour of such tumors, but when performed manually is a time-consuming task. Deep convolutional models can help in the analysis of spheroid images since they provide accurate results for the segmentation of tumors, a task that is necessary to further study features of spheroids. However, the images from tumor spheroids greatly vary depending on the experimental conditions, and also on the equipment (microscopes) and conditions (focus and magnification) employed to capture the images. This issue, known as domain shift, hinders the applicability of deep learning models for spheroid segmentation. In this work, we address this problem by studying style transfer methods based on both convolutional neural networks and generative adversarial networks to transfer the style from the images used for training segmentation models to the images from a new domain. This approach successfully handled the domain shift problem in the context of spheroid segmentation for 6 different deep learning models. Finally, we developed a high-level API that facilitates the of our approach to other contexts where the domain-shift problem might occur.

General-purpose data stream processing on heterogeneous architectures with WindFlow

Many emerging applications analyze data streams by running graphs of communicating tasks called operators. To develop and deploy such applications, Stream Processing Systems (SPSs) like Apache Storm and Flink have been made available to researchers and practitioners. They exhibit imperative or declarative programming interfaces to develop operators running arbitrary algorithms working on structured or unstructured data streams. In this context, the interest in leveraging hardware acceleration with GPUs has become more pronounced in high-throughput use cases. Unfortunately, GPU acceleration has been studied for relational operators working on structured streams only, while non-relational operators have often been overlooked. This paper presents WindFlow, a library supporting the seamless GPU offloading of general partitioned-stateful operators, extending the range of operators that benefit from hardware acceleration. Its design provides high throughput still exposing a high-level API to users compared with the raw utilization of GPUs in Apache Flink.

Prompting Is Programming: A Query Language for Large Language Models

Large language models have demonstrated outstanding performance on a wide range of tasks such as question answering and code generation. On a high level, given an input, a language model can be used to automatically complete the sequence in a statistically-likely way. Based on this, users prompt these models with language instructions or examples, to implement a variety of downstream tasks. Advanced prompting methods can even imply interaction between the language model, a user, and external tools such as calculators. However, to obtain state-of-the-art performance or adapt language models for specific tasks, complex task- and model-specific programs have to be implemented, which may still require ad-hoc interaction.Based on this, we present the novel idea of Language Model Programming (LMP). LMP generalizes language model prompting from pure text prompts to an intuitive combination of text prompting and scripting. Additionally, LMP allows constraints to be specified over the language model output. This enables easy adaption to many tasks while abstracting language model internals and providing high-level semantics.To enable LMP, we implement LMQL (short for Language Model Query Language), which leverages the constraints and control flow from an LMP prompt to generate an efficient inference procedure that minimizes the number of expensive calls to the underlying language model.We show that LMQL can capture a wide range of state-of-the-art prompting methods in an intuitive way, especially facilitating interactive flows that are challenging to implement with existing high-level APIs. Our evaluation shows that we retain or increase the accuracy on several downstream tasks, while also significantly reducing the required amount of computation or cost in the case of pay-to-use APIs (26-85% cost savings).

EXtreme Gradient Boosting Algorithm with Machine Learning: a Review

The primary task of machine learning is to extract valuable information from the data that is generated every day, process it to learn from it, and take useful actions. Original language process, pattern detection, search engines, medical diagnostics, bioinformatics, and chemical informatics are all examples of application areas for machine learning. XGBoost is a recently released machine learning algorithm that has shown exceptional capability for modeling complex systems and is the most superior machine learning algorithm in terms of prediction accuracy and interpretability and classification versatility. XGBoost is an enhanced distributed scaling enhancement library that is built to be extremely powerful, adaptable, and portable. It uses augmented scaling to incorporate machine learning algorithms. it is a parallel tree boost that addresses a variety of data science problems quickly and accurately. Python remains the language of choice for scientific computing, data science, and machine learning, which boosts performance and productivity by enabling the use of clean low-level libraries and high-level APIs. This paper presents one of the most prominent supervised and semi-supervised learning (SSL) machine learning algorithms in a Python environment.

Design of a Standard and Programmatically Accessible Interface for Smart Meters to Allow Monitoring Automation of the Energy Consumed by the Execution of Computer Software

Software has become more computationally demanding nowadays, turning out high-performance software in many cases, implying higher energy and economic expenditure. Indeed, many studies have arisen within the IT community to mitigate the environmental impact of software. Collecting and measuring software’s power consumption has become an essential task. This paper proposes the design of a standard interface for any currently available smart meter, which is programmatically accessible from any software application and can collect consumption data transparently while a program is executed. This interface is structured into two layers. The former is a driver that provides an OS-level standard interface to the meter, while the latter is a proxy offering higher-level API for a concrete programming language. This design provides many benefits. It makes it possible to substitute the meter for a different device without affecting the proxy layer. It also allows the presence of multiple proxy implementations to offer a programmatic interface to the meter for several languages. A prototype of the proposed interface design has been implemented for a concrete smart meter and OS to demonstrate its feasibility. It has been tested with two experiments. Firstly, its correct functioning has been validated. Later, the prototype has been applied to monitor the execution of a high-performance program, a machine learning application to select the most relevant features of electroencephalogram data.

IXIAM: ISA EXtension for Integrated Accelerator Management

During the last years, hardware accelerators have been gaining popularity thanks to their ability to achieve higher performance and efficiency than classic general-purpose solutions. They are fundamentally shaping the current generations of Systems-on-Chip (SoCs), which are becoming increasingly heterogeneous. However, despite their diffusion, a standard, general solution to manage them while providing speed and consistency has not yet been found. Common methodologies rely on OS mediation and a mix of user-space and kernel-space drivers, which can be inefficient, especially for fine-grained tasks. This paper addresses these sources of inefficiencies by proposing an <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">ISA eXtension for Integrated Accelerator Management</i> (IXIAM), a cost-effective HW-SW framework to control a wide variety of accelerators in a standard way, and directly from the cores. The proposed instructions include reservation, work offloading, data transfer, and synchronization. They can be wrapped in a high-level software API or even integrated into a compiler. IXIAM features also a user-space interrupt mechanism to signal events directly to the user process. We implement it as a RISC-V extension in the gem5 simulator and demonstrate detailed support for complex accelerators, as well as the ability to specify sequences of memory transfers and computations directly from the ISA and with significantly lower overhead than driver-based schemes. IXIAM provides a performance advantage that is more evident for small and medium workloads, reaching around 90× in the best case. This way, we enlarge the set of workloads that would benefit from hardware acceleration.

Tension: A Python package for FORCE learning.

First-Order, Reduced and Controlled Error (FORCE) learning and its variants are widely used to train chaotic recurrent neural networks (RNNs), and outperform gradient methods on certain tasks. However, there is currently no standard software framework for FORCE learning. We present tension, an object-oriented, open-source Python package that implements a TensorFlow / Keras API for FORCE. We show how rate networks, spiking networks, and networks constrained by biological data can all be trained using a shared, easily extensible high-level API. With the same resources, our implementation outperforms a conventional RNN in loss and published FORCE implementations in runtime. Our work here makes FORCE training chaotic RNNs accessible and simple to iterate, and facilitates modeling of how behaviors of interest emerge from neural dynamics.

Psm_utils: A High-Level Python API for Parsing and Handling Peptide-Spectrum Matches and Proteomics Search Results.

A plethora of proteomics search engine output file formats are in circulation. This lack of standardized output files greatly complicates generic downstream processing of peptide-spectrum matches (PSMs) and PSM files. While standards exist to solve this problem, these are far from universally supported by search engines. Moreover, software libraries are available to read a selection of PSM file formats, but a package to parse PSM files into a unified data structure has been missing. Here, we present psm_utils, a Python package to read and write various PSM file formats and to handle peptidoforms, PSMs, and PSM lists in a unified and user-friendly Python-, command line-, and web-interface. psm_utils was developed with pragmatism and maintainability in mind, adhering to community standards and relying on existing packages where possible. The Python API and command line interface greatly facilitate handling various PSM file formats. Moreover, a user-friendly web application was built using psm_utils that allows anyone to interconvert PSM files and retrieve basic PSM statistics. psm_utils is freely available under the permissive Apache2 license at https://github.com/compomics/psm_utils.

FasterAI: A Lightweight Library for Neural Networks Compression

FasterAI is a PyTorch-based library, aiming to facilitate the use of deep neural network compression techniques, such as sparsification, pruning, knowledge distillation, or regularization. The library is built with the purpose of enabling quick implementation and experimentation. More particularly, compression techniques are leveraging callback systems of libraries, such as fastai and Pytorch Lightning to propose a user-friendly and high-level API. The main asset of FasterAI is its lightweight, yet powerful, simplicity of use. Indeed, because it has been developed in a very granular way, users can create thousands of unique experiments by using different combinations of parameters, with only a single line of additional code. This allows FasterAI to be suited for practical usage, as it contains the most common compression techniques available out-of-the-box, but also for research, as implementing a new compression technique usually boils down to writing a single line of code. In this paper, we propose an in-depth presentation of the different compression techniques available in FasterAI. As a proof of concept and to better grasp how the library is used, we present results achieved by applying each technique on a ResNet-18 architecture, trained on CALTECH-101.

DLPR: Deep Learning-Based Enhanced Pattern Recognition Frame-Work for Improved Myoelectric Prosthesis Control

In EMG based pattern recognition (EMG-PR), deep learning-based techniques have become more prominent for their self-regulating capability to extract discriminant features from large data-sets. Moreover, the performance of traditional machine learning-based methods show limitation to categorize over a certain number of classes and degrades over a period of time. In this paper, an accurate, robust, and fast convolutional neural network-based framework for EMG pattern identification is presented. To assess the performance of the proposed system, five publicly available and benchmark data-sets of upper limb activities were used. This data-set contains 49 to 52 upper limb motions (NinaPro DB1, NinaPro DB2, and NinaPro DB3), Data with force variation, and data with arm position variation for intact and amputated subjects. The classification accuracies of 92.18% (53 classes), 91.56% (49 classes), 84.98% (49 classes of amputees), 95.67% (6 classes with force variation), and 99.12% (8 classes with arm position variation) have been observed during the testing. The performance of the proposed system is compared with the state of art techniques in the literature. The findings demonstrate that classification accuracy and time complexity have been improved significantly. For signal pre-processing and deep learning techniques, Keras which is a high-level API for TensorFlow is utilised to build profound learning models. The proposed method has been tested on the Intel Core i7 3.5GHz, 7th Gen CPU with 8GB DDR4 RAM.

Controlling the Stage: A High-Level Control System for Virtual Audiences in Virtual Reality

This article presents a novel method for controlling a virtual audience system (VAS) in Virtual Reality (VR) application, called STAGE, which has been originally designed for supervised public speaking training in university seminars dedicated to the preparation and delivery of scientific talks. We are interested in creating pedagogicalnarratives: narratives encompass affective phenomenon and rather than organizing events changing the course of a training scenario, pedagogical plans using our system focus on organizing the affects it arouses for the trainees. Efficiently controlling a virtual audience towards a specific training objective while evaluating the speaker’s performance presents a challenge for a seminar instructor: the high level of cognitive and physical demands required to be able to control the virtual audience, whilst evaluating speaker’s performance, adjusting and allowing it to quickly react to the user’s behaviors and interactions. It is indeed a critical limitation of a number of existing systems that they rely on a Wizard of Oz approach, where the tutor drives the audience in reaction to the user’s performance. We address this problem by integrating with a VAS a high-level control component for tutors, which allows using predefined audience behavior rules, defining custom ones, as well as intervening during run-time for finer control of the unfolding of the pedagogical plan. At its core, this component offers a tool to program, select, modify and monitor interactive training narratives using a high-level representation. The STAGE offers the following features: i) a high-level API to program pedagogical narratives focusing on a specific public speaking situation and training objectives, ii) an interactive visualization interface iii) computation and visualization of user metrics, iv) a semi-autonomous virtual audience composed of virtual spectators with automatic reactions to the speaker and surrounding spectators while following the pedagogical plan V) and the possibility for the instructor to embody a virtual spectator to ask questions or guide the speaker from within the Virtual Environment. We present here the design, and implementation of the tutoring system and its integration in STAGE, and discuss its reception by end-users.

Counterfeit Currency Detection based on AI

Abstract: The use of technology has grown tremendously within the few years it has made it easier to have access to advanced printing equipment in the industry which resulted in color printing of currencies to produce counterfeit notes across the country. To eliminate such unethical activities of printing counterfeit currency it is mandatory to make a system that detects the fake currency, In systems such as a money exchanger for example ATMs and vending machines, counterfeit currency notes must be detected beforehand exchanging process takes place. In the past, there have been similar systems developed based on methods such as image processing techniques that are done on the Matlab platform and other such platforms these methods possess some limitations including being less efficient and time-consuming. Our system is designed to eliminate all of the above problems through the use of deep learning techniques by detecting the features of currencies and determining whether its fake with a great accuracy rate. our proposed system verifies the Indian currency notes using Deep learning, deep learning helps in extracting meaningful information from the dataset fed into the machine using a set of methods to perform the classification of images. Our project makes use of the deep learning framework TensorFlow and its high-level API Keras which simplifies the creation of the model making it easier to achieve a less time-consuming and accurate model. Index Terms: Currency Detection, Deep Learning, Deep Neural Network, Convolution Neural Network

The Celerity High-level API: C++20 for Accelerator Clusters

Providing convenient APIs and notations for data parallelism which remain accessible for programmers while still providing good performance has been a long-term goal of researchers as well as language and library designers. C++20 introduces ranges and views, as well as the composition of operations on them using a concise syntax, but the efficient implementation of these library features is restricted to CPUs. We present the Celerity High-level API, which makes similarly concise mechanisms applicable to GPUs and accelerators, and even distributed memory clusters of GPUs. Crucially, we achieve this very high level of abstraction without a significant negative impact on performance compared to a lower-level implementation, and without introducing any non-standard toolchain components or compilers, by implementing a C++ library infrastructure on top of the Celerity system. This is made possible by two central API design and implementation strategies, which form the core of our contribution. Firstly, gathering as much information as possible at compile-time and using metaprogramming techniques to automatically fuse several distinctly formulated processing steps into a single accelerator kernel invocation. And secondly, leveraging C++20 “Concepts” in order to avoid type erasure, allowing for highly efficient code generation. We have evaluated our approach quantitatively in a comparison to lower-level manual implementations of several benchmarks, demonstrating its low overhead. Additionally, we investigated the individual performance impact of our specific optimizations and design choices, illustrating the advantages afforded by a Concepts-based approach.

Improving Performance with SIMD Intrinsics

Computer application development has a long history. With the continuous development of hardware, both the software and the programming languages and frameworks that make application development possible have also changed. As we move forward in time, as more and more powerful computers become available, the level of programming languages has also risen to a higher level. Increasingly high-level APIs and languages have become available, pointers, memory allocations and releases have slowly disappeared from the area of the programming. However, with the transition to high-level languages, the optimization of programs or the possibility of it has been relegated to the background, because some efficiency-enhancing options are not available in high-level languages. This paper therefore delves deeper into the benefits of SSE/AVX based SIMD concurrency capabilities that are “forgotten” in everyday programming. The presented tests will show that there are reserves in the CPU that can be used to push certain performance limits further away.

Research on prediction method of section convergence and deformation of shield tunnel in operation period based on deep learning

Presently, the tunnel construction of China is changing from “mainly construction” to “equal emphasis on construction and maintenance”. In this context, tunnel structure inspection, monitoring, and maintenance technologies have developed rapidly. However, the effective use and in-depth mining of massive data has always been the most difficult point in this field. Based on deep learning technology, this paper carries out in-depth mining of the multi-source data of the tunnel structure, so that the convergence and deformation of the section during the operation of the shield tunnel is predicted in a short time. Taking the Nanjing Yangtze River shield tunnel project as an example, the indicators are screened based on the fluctuations of the pair wise correlation coefficients of all monitoring indicators. And based on the Keras (a high-level neural network API) framework, a short-term prediction model of the convergent deformation of the shield tube section at this location is established. The results show that the model successfully predicts the convergence of the tunnel section in the next 10 days, and the prediction accuracy reaches 93.6 %. The short-term prediction of key sections and the near warning sections is realized, so as to prevent it in advance.