While nowadays Machine Learning (ML) algorithms have achieved impressive prediction accuracy in various fields, their ability to provide an explanation for the output remains an issue. The explainability research field is precisely devoted to investigating techniques able to give an interpretation of ML algorithms’ predictions. Among the various approaches to explainability, we focus on GLEAMS: a decision tree-based solution that has proven to be rather promising under various perspectives, but suffers a sensible increase in the execution time as the problem size grows. In this work, we analyse the state-of-the-art parallel approaches to decision tree-building algorithms and we adapt them to the peculiar characteristics of GLEAMS. Relying on an increasingly popular distributed computing engine called Ray, we propose and implement different parallelization strategies for GLEAMS. An extensive evaluation highlights the benefits and limitations of each strategy and compares the performance with other existing explainability algorithms. • Investigates different parallel approaches for GLEAMS explainability algorithm. • Analyses existing parallelization strategies for decision tree building algorithms. • The implementation leverages a popular distributed computing engine, Ray. • A comparison of the performance of the different parallel strategies is presented.

The scale of nowadays High Performance Computing (HPC) systems is the key element that determines the achievement of impressive performance, as well as the reason for their relatively limited reliability. Over the last decade, specific areas of the HPC research field have addressed the issue at different levels, by enriching the infrastructure, the platforms, or the algorithms with fault tolerance features. In this work, we focus on the rather-pervasive task of computing the solution of a dense, unstructured linear system and we propose an algorithm-based technique to obtain fault tolerance to multiple anywhere-located faults during the parallel computation. We particularly study the ways to boost the performance of the rollback-free recovery, and we provide an extensive evaluation of our technique w.r.t. to other state-of-the-art algorithm-based methods.

Despite the indisputable progresses of artificial intelligence, some tasks that are rather easy for a human being are still challenging for a machine. An emblematic example is the resolution of mathematical puzzles with diagrams. Sub-symbolical approaches have proven successful in fields like image recognition and natural language processing, but the combination of these techniques into a multimodal approach towards the identification of the puzzle’s answer appears to be a matter of reasoning, more suitable for the application of a symbolic technique. In this work, we employ logic programming to perform spatial reasoning on the puzzle’s diagram and integrate the deriving knowledge into the solving process. Analysing the resolution strategies required by the puzzles of an international competition for humans, we draw the design principles of a Prolog reasoning library, which interacts with image processing software to formulate the puzzle’s constraints. The library integrates the knowledge from different sources, and relies on the Prolog inference engine to provide the answer. This work can be considered as a first step towards the ambitious goal of a machine autonomously solving a problem in a generic context starting from its textual-graphical presentation. An ability that can help potentially every human–machine interaction.

As the need to understand and formalise business processes into a model has grown over the last years, the process discovery research field has gained more and more importance, developing two different classes of approaches to model representation: procedural and declarative. Orthogonally to this classification, the vast majority of works envisage the discovery task as a one-class supervised learning process guided by the traces that are recorded into an input log. In this work instead, we focus on declarative processes and embrace the less-popular view of process discovery as a binary supervised learning task, where the input log reports both examples of the normal system execution, and traces representing a “stranger” behaviour according to the domain semantics. We therefore deepen how the valuable information brought by both these two sets can be extracted and formalised into a model that is “optimal” according to user-defined goals. Our approach, namelyNegDis, is evaluated w.r.t. other relevant works in this field, and shows promising results regarding both the performance and the quality of the obtained solution.

As large-scale linear equation systems are pervasive in many scientific fields, great efforts have been done over the last decade in realizing efficient techniques to solve such systems, possibly relying on High Performance Computing (HPC) infrastructures to boost the performance. In this framework, the ever-growing scale of supercomputers inevitably increases the frequency of faults, making it a crucial issue of HPC application development.A previous study [1] investigated the possibility to enhance the Inhibition Method (IMe) -a linear systems solver for dense unstructured matrices-with fault tolerance to single hard errors, i.e. failures causing one computing processor to stop.This article extends [1] by proposing an efficient technique to obtain fault tolerance to multiple hard errors, which may occur concurrently on different processors belonging to the same or different machines. An improved parallel implementation is also proposed, which is particularly suitable for HPC environments and moves towards the direction of a complete decentralization. The theoretical analysis suggests that the technique (which does not require check pointing, nor rollback) is able to provide fault tolerance to multiple faults at the price of a small overhead and a limited number of additional processors to store the checksums. Experimental results on a HPC architecture validate the theoretical study, showing promising performance improvements w.r.t. a popular fault-tolerant solving technique.

The ever-increasing size of High Performance Computing (HPC) systems inevitably causes an unwanted decrease of Mean Time Between Failures (MTBF). For this reason, over the last decade, much work has been done on the topic of fault tolerance for supercomputers. In particular, as large-scale linear algebra applications permeate many scientific fields, important efforts have been focused on the performance enhancements that could be provided by HPC infrastructures if reliable fault tolerant solutions are adopted. This article explores a popular topic of linear algebra (i.e., linear equation system resolution) and proposes an efficient, error-resilient approach based on an existing technique called Inhibition Method (IMe). Initially conceived to analyse complex electric circuits and later extended to solve linear systems, the original method is here enhanced with a simple, yet effective strategy to provide tolerance to single fail-stop recurring to neither checkpointing, nor rollbacks. Experimental results on a medium-scale HPC architecture show negligible overheads and promising performance improvements when compared with a popular fault-tolerant solving technique.

The adoption of mobile devices and sensors, and the Internet of Things trend, are making available a huge quantity of information that needs to be analyzed. Distributed architectures, such as Map Reduce, are indeed providing technical answers to the challenge of processing these big data. Due to the distributed nature of these solutions, it can be difficult to guarantee the Quality of Service: e.g., it might be not possible to ensure that processing tasks are performed within a temporal deadline, due to specificities of the infrastructure or processed data itself. However, relaying on cloud infrastructures, distributed applications for data processing can easily be provided with additional resources, such as the dynamic provisioning of computational nodes. In this paper, we focus on the step of monitoring Map Reduce applications, to detect situations where resources are needed to meet the deadlines. To this end, we exploit some techniques and tools developed in the research field of Business Process Management: in particular, we focus on declarative languages and tools for monitoring the execution of business process. We introduce a distributed architecture where a logic-based monitor is able to detect possible delays, and trigger recovery actions such as the dynamic provisioning of further resources.