Reviewerly/exHarmony huggingface dataset:
Context aware Markov chains models

For more than a century, Markov chain models have had a tremendous effect on research and industry alike in various domains such as physics, chemistry, biology, and computer science. However, limited research has been performed on how to incorporate contextual conditions into the modeling phase. Existing approaches are performed in an ad hoc manner or fail to consider multiple contextual dimensions simultaneously. Inspired by the main paradigms in context-aware recommender systems, we suggest five novel approaches for learning contextual Markov chain models. In particular we suggest three contextual pre-filtering models that operate by learning multiple sub-models from various data partitions, each tailored to specific contextual aspects; a contextual model that directly extents the Markovian model with the contextual features; and lastly, a post-filtering model, which serves to refine the predictions made by a traditional non-contextual model by considering the available contextual information. We evaluate the suggested methods in two use cases: analysis of web browsing activities, and attack propagation patterns in honeypot systems. Experiments with massive datasets that contain millions of records indicate that taking the context of modeled sequences into consideration can substantially improve the accuracy of predicting and ranking the next possible element in such sequences. Moreover, we demonstrate the high scalability of the suggested methods, making them suitable for analyzing a vast amount of sequential data.
TCX: Texture and channel swappings for domain generalization

Neural networks suffer performance degradation when the source and target data lie in a different distribution hampering direct deployment of the model to diverse target domains. To this end, domain generalization (DG) aims to generalize the model well to an unknown target domain by utilizing multiple source domains. This paper proposes two simple swapping mechanisms, texture and channel swapping (TCX), for DG. Texture swapping augments the source dataset by replacing textures of an image with other textures in source dataset to alleviate the texture bias problem in convolution neural networks (CNNs). Furthermore, channel swapping switches channels of input feature vectors of the classifier along with its labels to encourage the model to utilize more channels when classifying an image. Together, we expect the model to learn less domain-specific features but more generalized class-specific features resulting in better domain generalization performance. We demonstrate the effectiveness of our approach with state-of-the-art results on three domain generalization benchmarks.
CSC-GCN: Contrastive semantic calibration for graph convolution network

Graph convolutional networks (GCNs) have been successfully applied to node representation learning in various real-world applications. However, the performance of GCNs drops rapidly when the labeled data are severely scarce, and the node features are prone to being indistinguishable with stacking more layers, causing over-fitting and over-smoothing problems. In this paper, we propose a simple yet effective contrastive semantic calibration for graph convolution network (CSC-GCN), which integrates stochastic identity aggregation and semantic calibration to overcome these weaknesses. The basic idea is the node features obtained from different aggregation operations should be similar. Toward that end, identity aggregation is utilized to extract semantic features from labeled nodes, while stochastic label noise is adopted to alleviate the over-fitting problem. Then, contrastive learning is employed to improve the discriminative ability of the node features, and the features from different aggregation operations are calibrated according to the class center similarity. In this way, the similarity between unlabeled features and labeled ones from the same class is enhanced while effectively reducing the over-smoothing problem. Experimental results on eight popular datasets show that the proposed CSC-GCN outperforms state-of-the-art methods on various classification tasks.
A planar dimension measurement optimization method with metric information compensation

Visual dimension measurement is commonly required in industrial detection. However, monocular vision measurements have a low accuracy with large field of view (FOV), while multi-vision measurement involves multi-source information fusion and incurs a large computation overhead. Hence, we propose a planar dimension measurement optimization method with metric information compensation (PMOM). This method constructs a linear representation model of pixel metric information using images at different heights along the camera’s optical axis; designs a multi-resolution multi-dimensional key point mapping mechanism (KPM) to realize the projection from a coarse resolution image point to a fine resolution image block and the secondary optimization of measurement results. By utilizing pixel-level and subpixel-level object extraction algorithms for both coarse resolution and fine resolution image blocks, the algorithm’s complexity and data processing requirements are notably reduced. The paper includes a theoretical proof of the method’s effectiveness, shown by analyzing the measurement errors of different resolution images. Comparative experiments on the measurement of spacing between planar patterns and workpiece machining accuracy validate the method meeting the requirements of industrial high-precision with a large FOV and low computational overhead.
Improvement of Two-swarm Cooperative PSO using Gaussian Process Regression

Particle Swarm Optimization (PSO) is a type of evolutionary computation developed to mimic the behaviour of a flock of birds searching for food. Particles with positional information and velocity search for solutions as they move through the search space, sharing information across all particles to efficiently search for solutions. In PSO, only the positional information of the best solution is shared to update the velocity, which causes problems such as insufficient search, failure to find a global solution, and early convergence to a local solution. Sun and Li (2014) have proposed TCPSO (Two-swarm Cooperative Particle Swarm Optimization) with a slave particle swarm for intensive solution exploration. However, for high-dimensional and complex problems, even TCPSO sometimes falls into the trap of local solutions. This paper aims to improve the performance of TCPSO by using a Gaussian process to estimate the approximate shape of the function of the problem in the solution search process.
Abstract Machines

Abstraction mechanisms play a crucial role in computing because they allow us to manage the complexity inherent in most computational systems by isolating the important aspects in a dedicated context. In the field of programming languages, these mechanisms are fundamental, both from a theoretical viewpoint (many important concepts can be appropriately formalised using abstractions) and in the practical sense, because programming languages today use common abstraction-creating constructs. One of the most general concepts employing abstraction is the abstract machine. In this chapter, we will see how this concept is closely related to the that of the programming language. We will also see how, without requiring us to go into the specific details of any particular implementation, it allows us to describe what an implementation of a programming language is. To do this, we will describe in general terms what is meant by the interpreter and the compiler for a language. Finally, will see how abstract machines can be structured in hierarchies that describe and implement complex software systems.
Object-Oriented Paradigm

In this chapter, we discuss object-oriented languages. We attempt to present the linguistic aspects which concern objects and their use, starting with a presentation of objects as a way to gain data abstraction in a way that is both flexible and extensible. This will lead us to describe the concepts of objects and classes, and, then, those of encapsulation, subtypes (that is a compatibility relation based on the functionality of an object), inheritance (that is the possibility of reusing the implementation of a method previously defined in another object or for another class), and dynamic method selection. Having examined these characteristic aspects in detail, we will study some extensions to linguistic solutions that are available in commercial languages, referring, in particular, to the concepts of subtype, polymorphism and genericity.
Concurrent Programming

We now consider a subject that is substantially different from those seen in the previous chapters. Up to now, we have considered sequential languages, where at each moment off the execution of a program there is only one active context. However, a significant part of modern programs, from operating system functions to web services, needs to escape this limitation. Indeed, to achieve their purpose, these programs need more than one context of execution, active at the same time, which concur to realize their functionalities. This kind of programming, called concurrent, is the subject of this chapter. After a brief introduction and a few historical notes, necessary to understand the vastness of the current panorama, we will see the main problems that arise when passing from sequential to concurrent programming and the related solutions. We will only outline the main ideas since an exhaustive treatment would require a further volume. Following the guiding principle of this entire text, we will not refer to any specific language for general principles, while we will try to make some notions concrete by examining the case of Java.
Structuring Data

Each programming language provides constructs and mechanisms for structuring data. These constructs and mechanisms are shaped by what is called the type system of a language. Types represent one of the salient characteristics of a programming language, which substantially differentiates one language from another. In this chapter, we will examine type systems, discussing primitive types and the mechanisms used to define new ones. Central to our presentation will be the concept of type safety. We will then tackle the questions of type equivalence and compatibility of types, that is mechanisms which allows to use a value of some type in a context requiring another type. We will discuss polymorphism and overloading. We will conclude the chapter with some questions about storage management (garbage collection), which is not, strictly speaking, a topic about data types but which well complements the examination of pointers which we must undertake.
Short Historical Perspective

The first electronic, programmable computers, and, therefore, the first programming languages, appeared at the end of the 1940s. Since then, many hundreds (if not thousands) of languages have been defined. In the previous chapters of this book, we have sought to identify the most important design and implementation characteristics that are common to large classes of contemporary languages. In this final chapter, we seek to understand what were the reasons that led, in the last seventy years, to the affirmation of these characteristics and hence to the success of some languages and the disappearance of many others.
Data Abstraction

In this chapter, we will present some of the main ways in which a language can provide mechanisms for defining abstractions over data, more sophisticated than just the definition of new types. Among these mechanisms, we will discuss the so-called abstract data types, which in different forms are provided by many different languages. We then look at modules, a largely similar concept, but which mainly applies to programming in the large. These abstraction mechanisms also constitute an introduction to some themes that we will encounter again with object-oriented programming. The key concepts that we will investigate in this chapter are the separation between interface and implementation and the concepts associated with information hiding.
Functional Programming Paradigm

In this chapter, we discuss the functional programming paradigm, where computation proceeds by term rewriting and not through modification of the state. Languages of this paradigm, at least in their “pure” form, do not use the concept of memory and therefore there is no side effect. Once an environment is fixed, an expression always denotes the same value. We will discuss the pure paradigm in the first sections, explaining its fundamental aspects. Real functional programming languages, however, merge these “pure” ingredients with many other mechanisms. We will, at this point, be in a position to discuss the reasons why the functional programming paradigm is interesting with respect to ordinary imperative languages. We will touch on the SECD machine, an abstract machine for higher-order functional languages which is the prototype of many real implementations. The chapter concludes with a more theoretical section that provides a succinct introduction to the lambda-calculus, a formal system for computability that inspires all functional languages and which has been a constant model for the design of programming languages.
Describing a Programming Language

A programming language is an artificial formalism in which algorithms can be expressed. For all its artificiality, though, this formalism remains a language. Its study can make good use of the many concepts and tools developed in the last century in linguistics (which studies both natural and artificial languages). Without going into great detail, this chapter poses the problem of what it means to “give” (define) a programming language and which tools can be used in this undertaking.
Names and the Environment

The evolution of programming languages can be seen in large measure as a process which has led, by means of appropriate abstraction mechanisms, to the definition of formalisms that are increasingly distant from the physical machine. In this context, names play a fundamental role. A name, indeed, is nothing more than a (possibly meaningful) sequence of characters used to represent some other thing. They allow the abstraction either of aspects of data, for example using a name to denote a location in memory, or aspects of control, for example representing a set of commands with a name. The correct handling of names requires precise semantic rules as well as adequate implementation mechanisms.
Comparing State of the Art Rule-Based Tools for Information Extraction

In this paper, we present a comparative analysis of the leading rule-based information extraction systems in both research and industry, focusing on their main characteristics and their performance. Our evaluation was performed on a dataset of text documents about financial product descriptions from a real-world application scenario. In this study, we demonstrate that, while the considered tools share similarities in terms of expressiveness of their extractors and produce results of comparable quality, the implementation choices of their engines have a substantial impact on their overall execution time. Moreover, we emphasize that some of the considered tools offer seamless support for writing extraction rules, effectively addressing one of the common challenges associated with rule-based approaches.
Layerwise Learning of Mixed Conjunctive and Disjunctive Rule Sets

Conventional rule learning algorithms learn a description of the positive class in disjunctive normal form (DNF). Alternatively, there are also a few learners who can formulate their model in conjunctive normal form (CNF) instead. While it is clear that both representations are equally expressive, there are domains where DNF learners perform better and others where CNF learners perform better. Thus, an algorithm that can dynamically make use of the best of both worlds is certainly desirable. In this paper, we propose the algorithm Cord that can learn general logical functions by training alternating layers of conjunctive and disjunctive rule sets, using any conventional rule learner. In each layer, the conjunctions/disjunctions trained in the previous layer are used as input features for learning a CNF/DNF expression that forms the next layer. In our experiments on real-world benchmark data, Cord outperformed both state-of-the-art CNF and DNF learners, where the best final performance was typically achieved using a high number of intermediate, general concepts in early layers that were refined in later layers, underlining the importance of more flexible and deeper concept representations.
Explaining Optimal Trajectories

We propose a definition of common explanation for the label shared by a group of observations described as first order interpretations, and provide algorithms to enumerate minimal common explanations. This was motivated by explaining how performing some action, for instance a card played during a card game play, results in winning a maximum total reward at the end of the trajectory. As there are various ways to reach this reward, each associated to a group of trajectories, we propose to first build groups of trajectories and then build minimal common explanations for each group. The whole method is illustrated on a simplified Bridge game.
A Case Study for Declarative Pattern Mining in Digital Forensics

In this short paper, we briefly describe the application of a declarative AI approach to a case study concerning the analysis of real-world phone recordings. In particular, we summarize the general results obtained for a couple of mining tasks, one being sequential pattern mining and the other contrast pattern mining, reformulated within the framework of Answer Set Programming.
FreeCHR: An Algebraic Framework for CHR-Embeddings

We introduce the framework FreeCHR which formalizes the embedding of Constraint Handling Rules (CHR) into a host language, using the concept of initial algebra semantics from category theory, to establish a high-level implementation scheme for CHR as well as a common formalization for both theory and practice. We propose a lifting of the syntax of CHR via an endofunctor in the category Set and a lifting of the very abstract operational semantics of CHR into FreeCHR, using the free algebra, generated by the endofunctor and give proofs for soundness and completeness w.r.t. their original definition.
Extension of Regression Tsetlin Machine for Interpretable Uncertainty Assessment

In our recent research, we modified the Regression Tsetlin Machine (RTM) to obtain uncertainties in regression prediction. The significance of this research is heightened when the factors leading to higher or lower uncertainties can be elucidated. For example, in the context of active learning, providing explanations such as “WHEN 4 < x1 < 10 AND x2 = 4 AND 105 < x3 AND ... THEN Variance is higher than 4” assists in generating additional samples around the specified input combination. However, due to the inherent nature of the Regression Tsetlin Machine, acquiring such rules is challenging. An alternative approach is to examine how the variance fluctuates in relation to a single variable while keeping other variables fixed. Nevertheless, to obtain rules that are easily understandable to humans, we expand upon our previous work by introducing an additional layer of the Tsetlin Machine, which classifies the uncertainties learned by the preceding layer of the RTM. In essence, the samples are grouped based on their uncertainty values and the clauses in the Tsetlin Machine learn sub-patterns associated with each class. First, using an artificial dataset, we show the importance of the proposed approach in explaining the uncertainties. Then, we showcase the practical application of our proposed approach in out-of-distribution (OOD) detection, utilizing a real estate valuation dataset. The obtained results provide compelling evidence that the RTM successfully identifies OOD samples. Moreover, the removal of these samples leads to a notable improvement in performance.
Knowledge Bases and Language Models: Complementing Forces

Large language models (LLMs), as a particular instance of generative artificial intelligence, have revolutionized natural language processing. In this invited paper, we argue that LLMs are complementary to structured data repositories such as databases or knowledge bases, which use symbolic knowledge representations. Hence, the two ways of knowledge representation will likely continue to co-exist, at least in the near future. We discuss ways that have been explored to make the two approaches work together, and point out opportunities and challenges for their symbiosis.
Marrying Query Rewriting and Knowledge Graph Embeddings

Knowledge graph embeddings (KGEs) are useful for creating a continuous and meaningful representation of the data present in knowledge graphs (KGs). While initially employed mainly for link prediction, there has been an increased interest in querying such models using richer query languages, exploiting their continuous nature to obtain answers with a certain degree of confidence, that would not come as a result of querying KGs used to train such models. KGs can greatly benefit from having an ontology expressing conceptual knowledge of the domain and there has already been intensive research in rewriting approaches for querying the data present in KGs while taking their ontologies into account. However, these approaches have not been employed yet to query KGEs. Taking the best of both worlds, in this work we combine query rewriting in the classical DL-Lite ontology language with KGEs. More specifically, we propose a unified framework for querying KGEs that performs query rewriting for DL-Lite ontologies. We perform experiments and discuss how this combination can successfully improve query results.
Fine-Tuning Large Enterprise Language Models via Ontological Reasoning

Large Language Models (LLMs) exploit fine-tuning as a technique to adapt to diverse goals, thanks to task-specific training data. Task specificity should go hand in hand with domain orientation, that is, the specialization of an LLM to accurately address the tasks of a given realm of interest. However, models are usually fine-tuned over publicly available data or, at most, over ground data from databases, ignoring business-level definitions and domain experience. On the other hand, Enterprise Knowledge Graphs (EKGs) are able to capture and augment such domain knowledge via ontological reasoning. With the goal of combining LLM flexibility with the domain orientation of EKGs, we propose a novel neurosymbolic architecture that leverages the power of ontological reasoning to build task- and domain-specific corpora for LLM fine-tuning.
Semantic Role Assisted Natural Language Rule Formalization for Intelligent Vehicle

This paper proposes a novel pipeline to translate natural language rules and instructions for intelligent vehicles into temporal logic. The pipeline uses semantic role labeling (SRL), soft rule-based selection restrictions, and large language models (LLMs) to extract predicates, arguments, and temporal aspects from natural language rules and instruction. We then use the language understanding capability of LLMs to generate temporal logic rules from unstructured natural language text and additional information provided by SRL. We envision our model as a human-in-the-loop system that can facilitate the automated rule formalization for planning and verification systems in automated driving and drone planning. We demonstrate that our method can generate semantically correct temporal logic formulas from natural language text and provide implicit explanations of the output by showing the intermediate reasoning steps involved. This paper illustrates the integration of additional semantic knowledge and LLM and its application for the intelligent system domain of automated driving and drone planning. Our generalizable pipeline can easily extend to new logic formalization types, traffic rules, drone planning instructions, and application domains.