1,156 research outputs found
Taming Existence in RDF Querying
We introduce the recursive, rule-based RDF query language
RDFLog. RDFLog extends previous RDF query languages by arbitrary
quantifier alternation: blank nodes may occur in the scope of all, some,
or none of the universal variables of a rule. In addition RDFLog is aware
of important RDF features such as the distinction between blank nodes,
literals and URIs or the RDFS vocabulary. The semantics of RDFLog is
closed (every answer is an RDF graph), but lifts RDF’s restrictions on
literal and blank node occurrences for intermediary data. We show how
to define a sound and complete operational semantics that can be implemented
using existing logic programming techniques. Using RDFLog
we classify previous approaches to RDF querying along their support for
blank node construction and show equivalence between languages with
full quantifier alternation and languages with only ∀∃ rules
ROMEO: Exploring Juliet through the Lens of Assembly Language
Automatic vulnerability detection on C/C++ source code has benefitted from
the introduction of machine learning to the field, with many recent
publications considering this combination. In contrast, assembly language or
machine code artifacts receive little attention, although there are compelling
reasons to study them. They are more representative of what is executed, more
easily incorporated in dynamic analysis and in the case of closed-source code,
there is no alternative. We propose ROMEO, a publicly available, reproducible
and reusable binary vulnerability detection benchmark dataset derived from the
Juliet test suite. Alongside, we introduce a simple text-based assembly
language representation that includes context for function-spanning
vulnerability detection and semantics to detect high-level vulnerabilities.
Finally, we show that this representation, combined with an off-the-shelf
classifier, compares favorably to state-of-the-art methods, including those
operating on the full C/C++ code.Comment: 6 pages, code available at https://gitlab.com/dlr-dw/rome
The Time has Come – Application of Artificial Intelligence in Small- and Medium-Sized Enterprises
Artificial intelligence (AI) is not yet widely used in small- and medium-sized industrial enterprises (SME). The reasons for this are manifold and range from not understanding use cases, not enough trained employees, to too little data. This article presents a successful design-oriented case study at a medium-sized company, where the described reasons are present. In this study, future demand forecasts are generated based on historical demand data for products at a material number level using a gradient boosting machine (GBM). An improvement of 15% on the status quo (i.e. based on the root mean squared error) could be achieved with rather simple techniques. Hence, the motivation, the method, and the first results are presented. Concluding challenges, from which practical users should derive learning experiences and impulses for their own projects, are addressed
Cross-Domain Evaluation of a Deep Learning-Based Type Inference System
Optional type annotations allow for enriching dynamic programming languages
with static typing features like better Integrated Development Environment
(IDE) support, more precise program analysis, and early detection and
prevention of type-related runtime errors. Machine learning-based type
inference promises interesting results for automating this task. However, the
practical usage of such systems depends on their ability to generalize across
different domains, as they are often applied outside their training domain. In
this work, we investigate Type4Py as a representative of state-of-the-art deep
learning-based type inference systems, by conducting extensive cross-domain
experiments. Thereby, we address the following problems: class imbalances,
out-of-vocabulary words, dataset shifts, and unknown classes. To perform such
experiments, we use the datasets ManyTypes4Py and CrossDomainTypes4Py. The
latter we introduce in this paper. Our dataset enables the evaluation of type
inference systems in different domains of software projects and has over
1,000,000 type annotations mined on the platforms GitHub and Libraries. It
consists of data from the two domains web development and scientific
calculation. Through our experiments, we detect that the shifts in the dataset
and the long-tailed distribution with many rare and unknown data types decrease
the performance of the deep learning-based type inference system drastically.
In this context, we test unsupervised domain adaptation methods and fine-tuning
to overcome these issues. Moreover, we investigate the impact of
out-of-vocabulary words.Comment: Preprint for the MSR'23 technical trac
- …