Reviewerly/exHarmony huggingface dataset:
Developing and Testing a Common Space Systems Ontology using the Ontological Modeling Language

This paper describes the development and testing of the initial version of a common space systems ontology (CoSSO) for use by the Advanced Concepts Office (ACO) at NASA's Marshall Space Flight Center. The ontology provides a shared conceptualization of concepts of interest to the ACO for modeling aerospace systems concepts in a pre-phase A context to aid with the transition to a more model-based paradigm. The ontological concepts and relations, as well as the anticipated use cases, were developed through interactions with the relevant subject matter experts at the ACO and implemented in the Ontological Modeling Language (OML). The ontology builds on the Basic Formal Ontology (BFO) and the Common Core Ontologies (CCO). While most of the ontology is still in the initial stages, an Environmental Control and Life Support System (ECLSS) ontology is being built on top of the main CoSSO and heavily developed as a proof of concept. The ECLSS ontology is designed with different use cases in mind, namely predicting and diagnosing errors in ECLS systems on long-duration missions, with a focus on the Four-Bed CO <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</inf> carbon dioxide scrubber currently on board the ISS. The ECLSS ontology is being developed in a similar manner to the CoSSO, and designed to be compatible with it. The current state of both ontologies is presented and discussed, along with plans for future development and testing.
PDA Technique for Track-to-Truth Assignment in the Presence of Sensor Biases and Small Objects

When conducting performance assessment of multi-target tracking algorithms with a realistic computer simulation or real-world sensor data, good track-to-truth assignment (TTA) is a critical component of any meaningful assessment. The presence of kinematic data for small objects that may not be observed by the sensor in the truth data poses serious challenges to the TTA. The assignment process is further complicated by the presence of sensor biases. In this paper, TTA in the presence of small objects and sensor biases is considered. When the target density is high and some objects are small, correctly assigning tracks to truth objects is challenging, and with the addition of sensor biases, the problem of correctly assigning tracks to truth objects is impossible without mitigation. The high rate of false switches of tracks between true objects greatly hinders the performance assessment of the target tracking system. In this paper, these challenges are addressed by adding probability of tracking to a probabilistic data association (PDA) technique for TTA. The computational algorithms for the implementation of the PDA technique are presented along with simulation results that confirm the effectiveness of the PDA approach in accurately estimating the sensor biases, and reducing the artificial track switches and ambiguity in the TTA.
SeMask-Mask2Former: A Semantic Segmentation Model for High Resolution Remote Sensing Images

With the development of remote sensing, semantic segmentation of high-resolution remote sensing images (RSIs) is increasingly essential. At the same time, the characteristics of objects in RSIs, such as large size, variation in object scales, and complex details, make it necessary to capture both long-range context and local information. There are some methods such as Fully Convolutional Networks (FCN) and Pyramid Scene Parsing Network (PSPNet) lack the ability to capture long-range dependencies, due to the limited receptive field of Convolutional Neural Network (CNN). However, the self-attention mechanism to capture the correlation between pixels in Transformer models has remarkable capability in capturing long-range context. One of the most outstanding Transformer models is the Masked-attention Mask Transformer (Mask2Former) which adopts the mask classification method. We propose a model SeMask-Mask2Former with boundary loss. Semantically Masked (Se-Mask) is the model's backbone and Mask2Former is the decoder. Concretely, the mask classification that generates one or even more masks for specific categories to perform the elaborate segmentation is especially suitable for handling the characteristic of large within-class and small inter-class variance of RSIs. Above all, extensive experimental results show that SeMask-Mask2Former obtains better results in semantic segmentation of high-resolution RSIs on the ISPRS Potsdam dataset compared to CNN-based methods and other state-of-the-art transformer-based methods. Extensive ablation studies conducted on the Potsdam dataset verifies the contribution of each component or optimization strategy in SeMask-Mask2Former.
Online Reinforcement Learning for Autonomous Sensor Control

For a heterogeneous sensor grid to achieve situational awareness over an area of interest and successfully detect, track, classify, and identify (DTCI) objects of interest, individual sensor platforms must be able to autonomously adapt to changing environments by modifying their controllable parameters in real-time. To this end, we propose a novel methodology for active sensor management by means of online reinforcement learning that simultaneously learns an optimal policy and discretizes the state-action space of interest through dictionary learning - learning of a finite set of representative state-action space. This method features minimal a priori assumptions on the state-action space, allowing for gradual adaptation of the policy to occur as a sensor observes new information. The major innovation is the use of dictionary learning to gradually determine the individual basis functions whose linear combination approximates the Q-function. We show in several physics-based photorealistic simulations, based on a real-world test and experimentation location represented in the Gazebo framework, that our methodology is capable of learning near-optimal policies while taking significantly less training time than is traditionally found in other reinforcement learning methods. These simulation results capture performance of several independent sensors monitoring the same area of interest with small amounts of field of view overlap. They set the foundation for future work where sensors interact to coordinate their adaptation to further enhance the resultant situational awareness.
Enhancing Comprehension and Navigation in Jupyter Notebooks with Static Analysis

Jupyter notebooks enable developers to interleave code snippets with rich-text and in-line visualizations. Data scientists use Jupyter notebook as the de-facto standard for creating and sharing machine-learning based solutions, primarily written in Python. Recent studies have demonstrated, however, that a large portion of Jupyter notebooks available on public platforms are undocumented and lacks a narrative structure. This reduces the readability of these notebooks. To address this shortcoming, this paper presents HeaderGen, a novel tool-based approach that automatically annotates code cells with categorical markdown headers based on a taxonomy of machine-learning operations, and classifies and displays function calls according to this taxonomy. For this functionality to be realized, HeaderGen enhances an existing call graph analysis in PyCG. To improve precision, HeaderGen extends PyCG's analysis with support for handling external library code and flow-sensitivity. The former is realized by facilitating the resolution of function return-types. Furthermore, HeaderGen uses type information to perform pattern matching on code syntax to annotate code cells.The evaluation on 15 real-world Jupyter notebooks from Kaggle shows that HeaderGen's underlying call graph analysis yields high accuracy (96.4% precision and 95.9% recall). This is because HeaderGen can resolve return-types of external libraries where existing type inference tools such as pytype (by Google), pyright (by Microsoft), and Jedi fall short. The header generation has a precision of 82.2% and a recall rate of 96.8% with regard to headers created manually by experts. In a user study, HeaderGen helps participants finish comprehension and navigation tasks faster. All participants clearly perceive HeaderGen as useful to their task.
Intelligent Constraint Classification for Symbolic Execution

Forward symbolic execution is a powerful systematic software analysis technique, but suffers from the high cost of constraint solving. During symbolic execution, off-the-shelf constraint solvers are used to check the satisfiability of path conditions whenever they are updated. However, the satisfiability information is sufficient for path exploration, while the concrete solutions are needed only for special cases, e.g., when a property violation is detected. Thus, symbolic execution can be made more efficient by leveraging rapid constraint classification instead of time-consuming constraint solving when the concrete solutions are not necessary. This paper introduces ICON, a novel approach to scaling symbolic execution with intelligent constraint classification, where neural networks are utilized to classify path conditions for satisfiability. Experimental evaluation shows ICON is highly accurate in classifying path conditions, is faster than state-of-the-art techniques for conventional constraint solving, learning based constraint solving, and constraint solution reuse, and enables more efficient symbolic execution.
Extending Source Code Pre-Trained Language Models to Summarise Decompiled Binaries

Binary reverse engineering is used to understand and analyse programs for which the source code is unavailable. Decompilers can help, transforming opaque binaries into a more readable source code-like representation. Still, reverse engineering is difficult and costly, involving considering effort in labelling code with helpful summaries. While the automated summarisation of decompiled code can help reverse engineers understand and analyse binaries, current work mainly focuses on summarising source code, and no suitable dataset exists for this task. In this work, we extend large pre-trained language models of source code to summarise de-compiled binary functions. Further-more, we investigate the impact of input and data properties on the performance of such models. Our approach consists of two main components; the data and the model. We first build CAPYBARA, a dataset of 214K decompiled function-documentation pairs across various compiler optimisations. We extend CAPYBARA further by removing identifiers, and deduplicating the data. Next, we fine-tune the CodeT5 base model with CAPYBARA to create BinT5. BinT5 achieves the state-of-the-art BLEU-4 score of 60.83, 58.82 and, 44.21 for summarising source, decompiled, and obfuscated decompiled code, respectively. This indicates that these models can be extended to decompiled binaries successfully. Finally, we found that the performance of BinT5 is not heavily dependent on the dataset size and compiler optimisation level. We recommend future research to further investigate transferring knowledge when working with less expressive input formats such as stripped binaries.
ClawSAT: Towards Both Robust and Accurate Code Models

We integrate contrastive learning (CL) with adversarial learning to co-optimize the robustness and accuracy of code models. Different from existing works, we show that code obfuscation, a standard code transformation operation, provides novel means to generate complementary ‘views’ of a code that enable us to achieve both robust and accurate code models. To the best of our knowledge, this is the first systematic study to explore and exploit the robustness and accuracy benefits of (multi-view) code obfuscations in code models. Specifically, we first adopt adversarial codes as robustness-promoting views in CL at the self-supervised pre-training phase. This yields improved robustness and transferability for downstream tasks. Next, at the supervised fine-tuning stage, we show that adversarial training with a proper temporally-staggered schedule of adversarial code generation can further improve robustness and accuracy of the pre-trained code model. Built on the above two modules, we develop ClawSAT, a novel self-supervised learning (SSL) framework for code by integrating CL with adversarial views (Claw) with staggered adversarial training (SAT). On evaluating three downstream tasks across Python and Java, we show that ClawSAT consistently yields the best robustness and accuracy (e.g. 11% in robustness and 6% in accuracy on the code summarization task in Python). We additionally demonstrate the effectiveness of adversarial learning in Claw by analyzing the characteristics of the loss landscape and interpretability of the pre-trained models. Codes are available at https://github.com/OPTML-Group/Claw-SAT.
Slice-Based Code Change Representation Learning

Code changes are at the very core of software development and maintenance. Deep learning techniques have been used to build a model from a massive number of code changes to solve software engineering tasks, e.g., commit message generation and bug-fix commit identification. However, existing code change representation learning approaches represent code change as lexical tokens or syntactical AST (abstract syntax tree) paths, limiting the capability to learn semantics of code changes. Besides, they mostly do not consider noisy or tangled code change, hurting the accuracy of solved tasks. To address the above problems, we first propose a slice-based code change representation approach which considers data and control dependencies between changed code and unchanged code. Then, we propose a pre-trained sparse Transformer model, named CCS2VEC, to learn code change representations with three pre-training tasks. Our experiments by fine-tuning our pre-trained model on three downstream tasks have demonstrated the improvement of CCS2VEC over the state-of-the-art CC2VEC.
Brigadier: A Datalog-based IAST framework for Node.js Applications

The NODE.JS runtime, in combination with Node Package Manager (NPM), is a popular ecosystem for building server-side web applications. Both JavaScript’s flexible and dynamic character and the vast amount of NPM libraries available can speed up the development of web applications. However, JavaScript and NODE.JS lack security mechanisms and abstractions. Despite the numerous language-based approaches proposed to protect JavaScript applications, no work supports application-level and business-level security properties. This means that in order to achieve both application-level and business-level security, developers are forced to rely on multiple different, unintegrated and incompatible tools and mechanisms.In this paper, we present BRIGADIER <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sup> , an interactive security testing framework for NODE.JS applications that enables the specification of both application-level and business-level security policies. Brigadier provides developers with a Datalog-based policy specification language that features close interoperability with running JavaScript programs under test. Input JavaScript programs are instrumented to emit relevant application events sent to a Datalog engine resulting from the compilation of the policies. We exhibit Brigadier’s expressiveness by implementing three case studies from the literature. We also assess Brigadier’s performance overhead on server-side applications. In our benchmarks, we observed a slowdown factor ranging from∼1.2x to ∼3x, which is acceptable for a testing scenario.
CSSAM: Code Search via Attention Matching of Code Semantics and Structures

Code search greatly improves developers’ coding efficiency by retrieving reusable code segments with natural language queries. Despite the continuous efforts in improving both the effectiveness and efficiency of code search, two issues remained unsolved. First, programming languages have inherent strong structural linkages, and feature mining of code as text form would omit the structural information contained inside it. Second, there is a potential semantic relationship between code and query, it is challenging to align code and text across sequences so that vectors are spatially consistent during similarity matching.To tackle both issues, in this paper, a code search model named CSSAM (Code Semantics and Structures Attention Matching) is proposed. By introducing semantic and structural matching mechanisms, CSSAM effectively extracts and fuses multidimensional code features. Specifically, the cross and co-attention layer was developed to facilitate high-latitude spatial alignment of code and query at the token level. By leveraging the residual interaction, a matching module is designed to preserve more code semantics and descriptive features, which enhances the relevance between the code and its corresponding query text. Besides, to improve the model’s comprehension of the code’s inherent structure, a code representation structure named CSRG (Code Semantic Representation Graph) is proposed for jointly representing abstract syntax tree nodes and the data flow of the codes. According to the experimental results on two publicly available datasets containing 475k and 330k code segments, CSSAM significantly outperforms the baselines in terms of achieving the highest SR@1/5/10, MRR, and NDCG@50 on both datasets, respectively. Moreover, the ablation study is conducted to quantitatively measure the impact of each key component of CSSAM on the efficiency and effectiveness of code search, which offers insights into the improvement of advanced code search solutions.
A Hierarchical Topical Modeling Approach for Recommending Repair of Quality Bugs

Quality bugs are difficult to detect because the implemented quality-related features are commonly scattered across the codebase. Unfortunately, this scattered information prevents software developers from holistically understanding the root cause of quality bugs. The traditional view of a system does not support a hierarchical code view for monitoring and tracing how quality features are topically related and how they interact with each other. In this paper, we show how these limitations can be overcome by leveraging a Hierarchical Dirichlet Process (HDP) topic modeling technique along with other supporting intermediary techniques such as structural and textual analyses to capture hierarchical topical relationships among quality features across the codebase that yield to detection of quality bugs. We present SoftQualTopicDetector, that is capable of clustering scattered quality concerns into a meaningful hierarchy to infer a set of candidate classes relevant for recommending repair of quality bugs. The higher the ranking of classes into a hierarchy the more relevant they are regarded to contain information about the bug under investigation. Additionally, SoftQualTopicDetector incorporates three rich visualization features for monitoring, prioritizing, and 3-D tracing of suspicious classes to enhance aspects of maintainability, functional suitability, and tracability. We conduct an empirical evaluation of SoftQualTopicDetector that shows an improvement over the baseline and the state-of-the-art by terms ≈17% and in of average precision and ≈21% recall respectively.
TAG: UML Activity Diagram Deeply Supervised Generation from Business Textural Specification

Unified modeling language (UML) activity diagrams depict the internal behavior of different program operations with the help of nodes and edges, describing the business logic in user requirements. Traditionally, requirements engineers and practitioners refer to business process documents and analyze them to build UML activity diagrams manually, which makes labor and time consuming. Recently, deep learning technology has been utilized in various fields and has achieved excellent results. We propose a novel pipeline, named TAG, for automatically generating UML activity diagrams based on deep learning. The inspiration for TAG is as follows: (1) Semantic roles <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sup> , such as signal and condition entities in texts, can be obtained via sequence labeling; (2) A business process document corresponds to a semantic role sequence. According to the predefined rules, the semantic role sequence is used to construct the graph neural network, and the temporal activity relationship in a business process document is predicted via multi-layer semantic fusion; (3) Use temporal activity relationships to generate UML activity diagrams automatically. The entire process was automatically completed. SAP is the largest non-American software company by revenue. We obtained the original data from the SAP website and sorted them as business process documents. After preliminary experiments, a temporal activity relationship prediction accuracy rate of 79.87% was achieved. Simultaneously, some business process documents are available from https://github.com/lwx142857/bussiness-process.
Topic Recommendation for GitHub Repositories: How Far Can Extreme Multi-Label Learning Go?

GitHub is one of the most popular platforms for version control and collaboration. In GitHub, developers are able to assign related topics to their repositories, which is helpful for finding similar repositories. The topics that are assigned to repositories are varied and provide salient descriptions of the repository; some topics describe the technology employed in a project, while others describe functionality of the project, its goals, and its features. Topics are part of the metadata of a repository and are useful for the organization and discoverability of the repository. However, the number of topics is large and this makes it challenging to assign a relevant set of topics to a repository. While prior studies filter out infrequently occurring topics before their experiments, we find that these topics form the majority of the data.In this study, we try to address the problem of identifying the topics from a GitHub repository by treating it as an extreme multi-label learning (XML) problem. We collect data of 21K GitHub repositories containing 37K labels of topics. The main challenge for XML is a large number of possible labels and severe data sparsity which fit the challenge of identification of topics from the GitHub repository. We evaluate multiple XML techniques, such as Parabel, Bonsai, LightXML, and ZestXML. We then perform an analysis of the different models proposed for XML classification. The best results on all the metrics from XML models are from ZestXML which is a combination of zero-shot and XML. We also compare the performance of ZestXML with a baseline from a recent study. The results show that ZestXML improves the baseline in terms of the average F1-score by 17.35%. We also find that for the repositories that have topics that rarely appear in the repositories used during training, ZestXML improves the performance greatly. The average of F1-score is 3 times higher as compared to the baseline for the topics with 20 or less occurrences in training data.