Autonomous agents embedded in a physical environment need the ability to recognize objects and their properties from sensory data. Such a perceptual ability is often implemented by supervised machine learning models, which are pre-trained using a set of labelled data. In real-world, open-ended deployments, however, it is unrealistic to assume to have a pre-trained model for all possible environments. Therefore, agents need to dynamically learn/adapt/extend their perceptual abilities online, in an autonomous way, by exploring and interacting with the environment where they operate. This paper describes a way to do so, by exploiting symbolic planning. Specifically, we formalize the problem of automatically training a neural network to recognize object properties as a symbolic planning problem (using PDDL). We use planning techniques to produce a strategy for automating the training dataset creation and the learning process. Finally, we provide an experimental evaluation in both a simulated and a real environment, which shows that the proposed approach is able to successfully learn how to recognize new object properties.

Autonomous agents embedded in a physical environment need the ability to correctly perceive the state of the environment from sensory data. In partially observable environments, certain properties can be perceived only in specific situations and from certain viewpoints that can be reached by the agent by planning and executing actions. For instance, to understand whether a cup is full of coffee, an agent, equipped with a camera, needs to turn on the light and look at the cup from the top. When the proper situations to perceive the desired properties are unknown, an agent needs to learn them and plan to get in such situations. In this paper, we devise a general method to solve this problem by evaluating the confidence of a neural network online and by using symbolic planning. We experimentally evaluate the proposed approach on several synthetic datasets, and show the feasibility of our approach in a real-world scenario that involves noisy perceptions and noisy actions on a real robot.

In this paper, we present a novel approach to incrementally learn an Abstract Model of an unknown environment, and show how an agent can reuse the learned model for tackling the Object Goal Navigation task. The Abstract Model is a finite state machine in which each state is an abstraction of a state of the environment, as perceived by the agent in a certain position and orientation. The perceptions are high-dimensional sensory data (e.g., RGB-D images), and the abstraction is reached by exploiting image segmentation and the Taskonomy model bank. The learning of the Abstract Model is accomplished by executing actions, observing the reached state, and updating the Abstract Model with the acquired information. The learned models are memorized by the agent, and they are reused whenever it recognizes to be in an environment that corresponds to the stored model. We investigate the effectiveness of the proposed approach for the Object Goal Navigation task, relying on public benchmarks. Our results show that the reuse of learned Abstract Models can boost performance on Object Goal Navigation.

We propose an approach to learn an extensional representation of a discrete deterministic planning domain from observations in a continuous space navigated by the agent actions. This is achieved through the use of a perception function providing the likelihood of a real-value observation being in a given state of the planning domain after executing an action. The agent learns an extensional representation of the domain (the set of states, the transitions from states to states caused by actions) and the perception function on-line, while it acts for accomplishing its task. In order to provide a practical approach that can scale up to large state spaces, a “draft” intensional (PDDL-based) model of the planning domain is used to guide the exploration of the environment and learn the states and state transitions. The proposed approach uses a novel algorithm to (i) construct the extensional representation of the domain by interleaving symbolic planning in the PDDL intensional representation and search in the state transition graph of the extensional representation; (ii) incrementally refine the intensional representation taking into account information about the actions that the agent cannot execute. An experimental analysis shows that the novel approach can scale up to large state spaces, thus overcoming the limits in scalability of the previous work.

The automated learning of action models is widely recognised as a key and compelling challenge to address the difficulties of the manual specification of planning domains. Most state-of-the-art methods perform this learning offline from an input set of plan traces generated by the execution of (successful) plans. However, how to generate informative plan traces for learning action models is still an open issue. Moreover, plan traces might not be available for a new environment. In this paper, we propose an algorithm for learning action models online, incrementally during the execution of plans. Such plans are generated to achieve goals that the algorithm decides online in order to obtain informative plan traces and reach states from which useful information can be learned. We show some fundamental theoretical properties of the algorithm, and we experimentally evaluate the online learning of the action models over a large set of IPC domains.

The most common representation formalisms for planning are descriptive models. They abstractly describe what the actions do and are tailored for efficiently computing the next state(s) in a state transition system. But acting requires operational models that describe how to do things, with rich control structures for closed-loop online decision-making. Using descriptive representations for planning and operational representations for acting can lead to problems with developing and verifying consistency of the different models.We define and implement an integrated acting-and-planning system in which both planning and acting use the same operational models, which are written in a general-purpose hierarchical task-oriented language offering rich control structures. The acting component is inspired by the well-known PRS system, except that instead of being purely reactive, it can get advice from the planner. Our planning algorithm, RAEplan, plans by doing Monte Carlo rollout simulations of the actor’s operational models. Our experiments show significant benefits in the efficiency of the acting and planning system.

A key challenge posed by the Internet of Services is that applications need to cope with a continuously changing environment, both in terms of the context in which they operate and of the services, users and providers involved. Differently from applications where traditional change detection and adaptation mechanisms can be used, the Internet of Services requires systems that are adaptive by design. In this paper we present a design for adaptation framework supporting the modeling, development and operation of service based applications operating in highly dynamic environments. The approach exploits advanced techniques for dynamic and incremental service composition, allowing to effectively deal with changes occurring at different levels in the system. An implementation of the proposed solution is presented and evaluated on a real-world scenario from the Smart Urban Mobility domain.

In a recent position paper in Artificial Intelligence, we argued that the automated planning research literature has underestimated the importance and difficulty of deliberative acting, which is more than just interleaving planning and execution. We called for more research on the AI problems that emerge when attempting to integrate acting with planning. To provide a basis for such research, it will be important to have a formalization of acting that can be useful in practice. This is needed in the same way that a formal account of planning was necessary for research on planning. We describe some first steps toward developing such a formalization, and invite readers to carry out research along this line.

The idea to build systems based on services, by reusing and combining software made available independently via different technologies and channels and dynamically organizing them into coherent processes, has a very well recognized potential. Achieving this potential stands crucially on the ability to recognize and exploit the context in which such applications operate, in terms of the available services, of the actual setup at run-time, and of the interaction with human actors. Changing contexts require run-time reaction, by adapting the ongoing overall process enacted by the service-based system to unexpected deviations. Continuous context-aware adaptation is hencefore a strong requirement in this setting. In this paper, we propose a service delivery platform designed for the continuous context-aware adaptation of service-based systems, based on the idea of monitoring the underlying context via a hierarchical model, and using the context to drive the choice and execution of adaptive pervasive flows. We describe the approach through an example from the smart cities e-mobility domain.

Service-Oriented Computing (SOC) is a new computing paradigm that utilizes services as the basic constructs to support the development of rapid, low-cost and easy composition of distributed applications even in heterogeneous environments. The promise of Service-Oriented Computing is a world of cooperating services where application components are assembled with little effort into a network of services that can be loosely coupled to create flexible dynamic business processes and agile applications that may span organizations and computing platforms. The subject of Service-Oriented Computing is vast and enormously complex, spanning many concepts and technologies that find their origins in diverse disciplines that are woven together in an intricate manner. In addition, there is a need to merge technology with an understanding of business processes and organizational structures, a combination of recognizing an enterprise's pain points and the potential solutions that can be applied to correct them. The material in research spans an immense and diverse spectrum of literature, in origin and in character. As a result research activities are very fragmented. This necessitates that a broader vision and perspective be established — one that permeates and transforms the fundamental requirements of complex applications that require the use of the Service-Oriented Computing paradigm. This paper provides a Service Oriented Computing Roadmap and places on-going research activities and projects in the broader context of this roadmap. This research roadmap launches four pivotal, inherently related, research themes to Service-Oriented Computing: service foundations, service composition, service management and monitoring and service-oriented engineering.

Service-centric systems are developed by composition and configuration of services, i.e., "software components that can be used but that are not owned". Services are most often not under control of consumers. They are indeed made available by third parties, they are autonomously developed and managed, and can in principle change without notification. Service Level Agreements (SLAs) define the exact conditions under which services are provided and consumed. From the point of view of the consumer, SLAs make explicitly available all the technical information required for using a service: interfaces and data structures, interaction protocols, security-related information, quality of services parameters and so on. They are therefore key elements for the development of software-centric systems. In this article we discuss one of the most interesting open challenges in the area of services and of SLAs: how to enable the usage of SLAs to support service adaptation and evolution. We discuss in particular two key roles that SLAs can play to this purpose, namely "SLAs for monitoring" and "SLAs for adaptation".

Several works address the problem of the automated composition of stateful services, e.g., specified in WS-BPEL. However, the key problem of their practical applicability in real composition scenarios is still open. Addressing this problem requires to provide an easy and affordable way to specify behaviors of component services and composition requirements, as well as composition techniques that are powerful enough to scale to scenarios of realistic size. In this paper we provide a first step towards addressing this problem by evaluating the feasibility and efficiency of a state-of-the art approach to automating the composition task on a real scenario that entails a high level of complexity: the Amazon e-commerce services and an e-payment service offered by an important Italian banking Group (Monte dei Paschi di Siena). We show the feasibility of the specification of composition requirements and of the automated generation of complex executable WS-BPEL processes, and analyze the possibility of reducing the effort in the composition task.

The run-time monitoring of Web service compositions has been widely acknowledged as a significant and challenging problem. In this paper, we propose a novel solution to the problem of monitoring Web services implemented in BPEL. We devise an architecture that clearly separates the business logic of a Web service from its monitoring functionality. The architecture supports both "instance monitors" that deal with the execution of a single instance of BPEL process, as well as "class monitors" that report aggregated information about all the instances of a BPEL process. We also define a language for the specification of instance and class monitors. The language allows for specifying boolean, statistic, and time-related properties. Finally, we devise a technique for the automatic translation of all these kinds of monitors to Java programs

One of the fundamental Ideas of Weh services and service oriented architecture is the possibility to develop new applications by composing existing services that are available on the Web. Several approaches have been proposed to tackle the problem of Web service composition, but little effort has been devoted so far to the problem of modeling the requirements of the composition. However, it is clear that the possibility to express requirements specifying complex interactions patterns among the component services is an essential step to cope with a wide range of composition problems. In this paper we present a new model which addresses one of the key aspects of composition requirements, namely the dataflow among the component services. We develop graphical notations and a formal theory for the new model and we integrate it within an existing automated composition framework

In this paper we propose a technique for the automated synthesis of new composite Web services. Given a set of abstract BPEL4WS descriptions of component services, and a composition requirement, we automatically generate an executable BPEL4WS process that, once deployed, is able to interact with the components to satisfy the requirement. We implement the proposed approach exploiting efficient synthesis techniques, and experiment with some case studies taken from real world applications and with a parameterized domain. We show that the technique can scale up to cases in, which the manual development of BPEL4WS composite services is not trivial and is time consuming.

We describe an attempt to bridge the gap between early requirements specification and formal methods. In particular, we propose a new specification language, called Formal Tropos, that is founded on the primitive concepts of early requirements frameworks (actor, goal, strategic dependency) (Yu, 1997), but supplements them with a rich temporal specification language. We also extend existing formal analysis techniques, in particular model checking, to allow for an automatic verification of relevant properties for an early requirements specification. Our preliminary experiments demonstrate that formal analysis reveals gaps and inconsistencies in early requirements that are by no means trivial to discover without the help of formal analysis tools.

This paper is a first attempt towards a theory for reactive planning systems, i.e. systems able to plan and control execution of plans in a partially known and unpredictable environment. We start from an experimental real-world application developed at IRST, discuss some of the fundamental requirements and propose a formal theory based on these requirements. The theory takes into account the following facts: (1) actions may fail, since they correspond to complex programs controlling sensors and actuators which have to work in an unpredictable environment; (2) actions need to acquire information from the real world by activating sensors and actuators; (3) actions need to generate and execute plans of actions, since the planner needs to activate different special-purpose planners and to execute the resulting plans.

Abstract. In this paper we describe an industrial application of formal methods. We have used model checking techniques to model and formally verify a rather complex software, i.e. part of the “safety logic” of a railway interlocking system. The formal model is structured to retain the reusability and scalability properties of the system being modelled. Part of it is defined once for all at a low cost, and re-used. The rest of the model can be mechanically generated from the designers' current specification language. The model checker is “hidden” to the user, it runs as a powerful debugger. Its performances are impressive: exhaustive analysis of quite complex configurations with respect to rather complex properties are run in the order of minutes. The main reason for this achievement is essentially a carefully designed model, which exploits all the behaviour evolution constraints. The re-usability/scalability of the model and the fact that formal verification is automatic and efficient are the key factors which open up the possibility of a real usage by designers at design time. We have thus assessed the possibility of introducing the novel technique in the development cycle with an advantageous costs/benefits relation.

In this article, we show how a system for automated deduction can be given computational reflection, i.e., can affect its own computation mechanism, by using the very same machinery implementing logical deduction. This feature, which we call computational reflection via mechanized logical deduction, provides both theoretical and practical advantages. First, the theorem prover can inspect, extend, and modify its own underlying theorem-proving strategies automatically. Second, mechanized logical deduction can be used to reason about the ways these strategies can be extended and modified and to prove correctness statements. This opens up the possibility of building systems that are able to perform correct and safe, reflective self-extension and self-modification. © 1996 John Wiley & Sons, Inc.

We are mainly interested in the development of CAD systems for interior design. An effective use of such systems relies to a large extent on the characteristics of their user interface. This paper describes NALIG, a system able to "understand" and "reason about" high level descriptions of spatial scenes. The user interacts with the system by using a natural language interface which, though very simple, is expressive enough to allow the description of complex configurations of objects. NALIG replies by drawing on the screen an image mirroring its own "understanding" of the scene described. The comprehension process has required the integration of different AI-techniques (e.g., natural language understanding, spatial reasoning, default and common sense reasoning).

We propose multicontext systems (MC systems) as a formal framework for the specification of complex reasoning. MC systems provide the ability to structure the specification of “global” reasoning in terms of “local” reasoning subpatterns. Each subpattern is modeled as a deduction in a context, formally defined as an axiomatic formal system. the global reasoning pattern is modeled as a concatenation of contextual deductions via bridge rules, i.e., inference rules that infer a fact in one context from facts asserted in other contexts. Besides the formal framework, in this article we propose a three-layer architecture designed to specify and automatize complex reasoning. At the first level we have object-level contexts (called s-contexts) for domain specifications. Problem-solving principles and, more in general, meta-level knowledge about the application domain is specified in a distinct context, called Problem-Solving Context (PSC). On top of s-contexts and PSC, we have a further context, called MT, where it is possible to specify strategies to control multicontext reasoning spanning through s-contexts and PSC. We show how GETFOL can be used as a computer tool for the implementation of MC systems and for the automatization of multicontext deductions. © 1995 John Wiley & Sons, Inc.