This paper illustrates advances over existing implementation work performed on DALI, which is a logic prolog-based framework for defining agents and Multi-Agent Systems (MAS) developed at University of L'Aquila since 1999, and publicly available. In previous work, DALI features were already extended in view of cognitive robotic applications and Complex Event Processing. Here, we show how to define and implement more efficient and versatile Multi-Agent Systems, capable to interact with real robots.
There is growing need for robots that can interact safely with people in everyday situations. These robots have to be able to anticipate the effects of their own actions as well as the actions and needs of the people around them. To achieve this, two streams of research need to merge, one concerned with physical systems specifically designed to interact with unconstrained environments and another focusing on control architectures that explicitly take into account the need to acquire and use experience. The merging of these two areas has brought about the field of Cognitive Robotics. This is a multidisciplinary science that draws on research in adaptive robotics as well as cognitive science and artificial intelligence, and often exploits models based on biological cognition. Cognitive robots achieve their goals by perceiving their environment, paying attention to the events that matter, planning what to do, anticipating the outcome of their actions and the actions of other agents, and learning from the resultant interaction. They deal with the inherent uncertainty of natural environments by continually learning, reasoning, and sharing their knowledge.
Several papers on cognitive robotics can be found in the proceedings of main Conferences on Artificial Intelligence (e.g., ECAI, IJCAI) and on Agents (e.g., AAMAS). Cognitive robotic systems able to interact safely with people in everyday situations can potentially help in any situation where there are persons in need of special assistance, primarily the elderly and the disabled, but possibly also children (not as a substitute but as a support to parents, family and caregivers). With the increase of life expectancy and the decrease of resources available to public health systems, the importance of developing “intelligent” adaptive robots can be particularly appreciated in view of the societal issue of providing effective support to many people in need while making the use of helth-related resources more effective and rational. These robots have to be able to anticipate the effects of their own actions as well as the actions and needs of the people around them.
Cognitive Robotics is thus potentially able to alleviate the healthcare and social
security systems from the burden of having to provide full-time highly specialized human
assistants while allowing elderly people to leave at home rather than be moved to an
institution. In [
Understandably, as demonstrated by experiments performed, e.g., by the group of
Prof. Johan Hoorn at Vrije Universiteit Amsterdam about “social robotics”, humans
prefer friendly interfaces and robots that show some kind of intelligent and also affective
and “emotional” behavior. Such experiments consider not only Artificial Intelligence
aspects, but also the impact of robots on the user. There is interesting ongoing work
also from the point of view of ethics [
We strongly believe that in this and other fields it can be advantageous to define a robot’s cognitive part as a logical agent or Multi-Agent System defined via declarative agent-oriented languages. There are many logic agent-oriented languages and architectures in computational logic apt to these aim, among which MetateM, 3APL, GOAL, AgentSpeak, Impact, KGP and DALI, that might be usefully exploited in robotics (or have potential robotic applications).
However, the DALI language in particular [
The contribution of [
This paper illustrates advances over the pre-existing implementation work performed with the aim to obtain more efficient and versatile Multi-Agent Systems, capable to interact with real robots (rather than with simulators). In particular, the new implementation adds the following non-trivial features: (i) heterogeneity, i.e., a MAS can now include not only DALI agents but also agents written in other logic-basedlanguage; (ii) run-time reconfiguration of a MAS, i.e., agents can be started, stopped, suspended during the MAS operation; (iii) real potential parallelism, i.e., agents’ execution is asynchronous (differently from previous implementation) and thus much more versatile and efficient; (iv) via the Redis open-source database/communication infrastructure 1, agents can seemingly interact with existing robot-oriented technologies and can thus command robots. Notice that in this paper we are not concerned with physical aspects concerning sensors, actuators, vision, etc., that are widely studied by specialists. We model hardware subcomponents via a layer of abstraction that builds a network of sources and sinks of asynchronous events (or commands) with associated values.
The paper is organized as follows. In Section 2 we recall the basic DALI language; in Section 3 we illustrate, by means of small though significant examples, the potential
applicability of DALI in robotic user monitoring and training. In Section 4 we recall the extension to robotics of the DALI implementation, and in Section 5 we intruduce the new further extensions that we have recently developed. Finally, in Section 6 we conclude. 2
DALI [
External events are syntactically indicated by the postfix E and we have reactive rules like evE :> Reaction: if an agent perceives the event ev then she will react as described by Reaction. The agent remembers to have reacted by converting an external event into a past event (postfix P). An event perceived but not yet reacted to is called “present event” and is indicated by postfix N.
Actions (indicated with postfix A) may have or not preconditions: in the former case, the actions are defined by actions rules like actA :< P recondition, in the latter case they are just action atoms. Similarly to events, actions that already took place are recorded as past actions.
Internal events is the feature that makes DALI agent agents proactive. An internal event is syntactically indicated by the postfix I, and its description is composed of two rules. The first one, ev : P recondition, contains the conditions (knowledge, past events, procedures, etc.) that must be true so that the reaction (in the second rule evI :> ActionT oDoA) may happen. Internal events are automatically attempted with a default frequency customizable by means of directives in the initialization file.
The DALI communication architecture [
DALI provides a plugin to an answer set solver, so complex reasoning tasks such
as, e.g., planning and preference handling can be performed in Answer Set
Programming (ASP), which is a state-of-the art technology for dealing with hard computational
problems (cf., among many, [
“Complex Event Processing” (CEP) has evolved into the paradigm of choice for the
development of monitoring vast quantities of event data to make automated decisions
and take time-critical actions. This is particularly important in software agents, in fact,
agents and multi-agent systems are able to manage rapid change and thus to allow for
scalability in applications aimed at supporting the ever-increasing level of interaction.
Work on CEP in DALI is presented in [
The robotic applications that we envisage concern, as outlined above, user monitoring and training in any context, but especially for the care of elderly and disabled persons.
Since [
Agents are able to be aware by prior knowledge or via some form of learning of
the behavioral patterns that the user is adopting, and to learn rules and plans also from
other agents (by imitation or being told); notice that a logical account of the program
modifications which are necessary in a learning process is provided by the EVOLP
approach [
drink :- arrive home:
This learned rule can possibly be associated with a certainty factor. When the rule becomes later confronted with subsequent experience, its certainty factor will be updated accordingly. Whenever this factor exceeds a threshold, this may lead to assert new meta-rules, such as:
USUALLY drink WHEN arrive home:
User monitoring can be performed via temporal-logic-like rules like the following one:
Such a rule acts as a constraint which has priority over former ones; so, the agent
will actively discourage the user to drink while taking medicines. In [
The following example concerns a robot aiding to supervise a baby, thus
relieving caregivers from some of their tasks. If the baby is hungry, then the robot should
feed the baby with available baby food (feeding is an action, indicated with postfix A)
paying attention to choose the healthier among those that the baby likes. Conjunction
food (F ); available(F ) provides a number of values for F , among which one is chosen.
In particular, the choice will correspond to a maximum in the partial order imposed by
the binary predicates best preferred and healthier in the given order. This construct
for complex preference, the p-set, was originally introduced in [
baby is hungryE :> ffeed babyA(F ) : food (F ); available babyf (F ) : best preferred ; healthier g: In the example below, the robot again assists parents taking care of a child. The child has to go to school (mandatory goal, indicated by postfix G) and is about to skip breakfast because she prefers cereals that unfortunately are finished. The agent, based upon the monitoring condition (never skip breakfast) will be able to suggest alternative food, in particular the best preferred among available options.
go to schoolG : NEVER skip breakfast (D ) :: cereals nished :::
suggestA(alternative food ) IN fcookies; cake slice : best preferred g: The monitoring component can however also include meta-axioms such as for instance the following one, which states that a user action which is necessary to reach a mandatory objective should necessarily be undertaken. The agent can fulfill this statement either by convincing the user to do so, or to resort to human caregivers’ help:
Such a meta-rule could be applied to practical cases such as the following: mandatory goal (healthy ): required (healthy ; take medicineA):
ASP modules can be exploited in order to plan actions which might be performed in given situations, and to extract necessary actions, which are those actions included in all possible plans. Given ASP module M (defined in a separate text file), in the example below reaction to event evE can be either any action which can be inferred (from M ) as a possible reaction, or a necessary action, again according to M . Events are indicated with postfix E, reaction is indicated with :> . Connective > expresses preference: the former option is preferred over the latter if the condition after the :- holds; necessary and action are distinguished predicates applicable over ASP modules’ results. So, in this sample rule necessary actions are preferred in a critical situation. Otherwise, any of the two options may be taken.
evE :> necessary (M; N )jaction(M; A) : M > A :- critical situation: The above examples are witnesses of a re-elaboration of past work on DALI in the perspective of cognitive robotics applications. Though small, the examples should have practically demonstrated that DALI has indeed the potential for acting as an agent language in this realm. However, a suitable interface between DALI agents and robotic hardware or simulators was lacking. Such an interface has been recently designed and implemented, and is presented in the next sections. 4
As discussed in [
For the development of DALI agents and MAS, a programmer can simply use any
text editor to write DALI agent programs and the necessary start/configuration scripts;
more proficiently, she could use a web-based system-independent integrated
development environment where agents editing is managed through an HTML5/AJAX-based
online editor, with start/stop command buttons and agents logs output for runtime
verification, handling signals and events from the DALI engine running in the background
(that isn’t a actually an IDE, but we can use these features to develop a DALI MAS).
The system is designed so as to be able to interact with external services by means of
JSON data events. An external service can be for instance a virtual robotics simulator
so that an entire complex anthropomorphic cognitive robot like the iCub [
The software components diagram in 3 shows how DALI has been encapsulated and integrated with other modules through a Python “glue code” layer, called PyDALI. Each DALI agent is an instance of the Prolog program “DALI Interpreter”. The multiplatform open source library pexpect (http://github.com/pexpect/pexpect) has been adopted for building a Python middle layer to automate the interaction with the Sicstus Prolog environment, seen as an instance of the class PySicstus. In this way, by abstracting via the PyDALI class, a DALI agent instance process can be configured, loaded, started, executed and terminated. A MAS can then be handled via the most abstract class “MAS”.
The Python code can then been imported into any Python program, thus allowing the interaction of DALI agents with other software modules/server/clients by means of asynchronous JSON events.
The Multi-standard DALI Bus is in essence a middle layer communication protocol that converts any JSON event coming from the outside world to an internal FIPA event in a Linda tuple space 2, that the DALI MAS thus receives as an external event. Specific actions performed within the DALI MAS can vice versa generate FIPA events that are converted into JSON event so as to send commands to external actuators, that can be either real robotic actuators or virtual robotic components. A typical runtime deployment diagram is depicted in Figure 4.
The central Multi-standard DALI bus collects asynchronous data events from different sources, translating them into counterparts in the Linda tuple space whenever an agent is the destination. It also collects action messages from agents and translates them into JSON structures compatible with the destination. There may also be external sensors that directly generate Linda tuple messages, or external sensors mediated by the Python container. 5
Koine´ DALI is the new extension of DALI that we present in this paper. It represents
the evolution of ServerDALI [
Runtime deployment diagram of the extended DALI architecture – A DALI MAS can be easily integrated with other applications using Redis both as a Database server and as a communication channel: events can be stored into Redis queues (FIFO) and then delivered to the MAS agents; – the user can customize a MAS configuration (i.e., clone agents, stop agents, etc.) at runtime via a Web Server Interface: the Command Actuator program will implement the changes on the MAS and Inter-MAS Redis will be used as an internal communication channel; – Agents composing a DALI MAS can use Inter-MAS Redis also as a database server to their own purposes; – a Koine´ DALI MAS can cooperate without problems with other MASs, programmed in other languages, and with object-oriented applications.
To create a Koine´ DALI MAS, we need to add to a DALI MAS the followings: – Redis2LINDA and StringESE libraries (https://github.com/ AAAI-DISIM-UnivAQ/Redis2LINDA-stringESE) to deliver messages from Redis to MAS – RedisClient library (https://github.com/AAAI-DISIM-UnivAQ/
RedisClient) to deliver messages from MAS agents to Redis – ServerPyProlog library (https://github.com/AAAI-DISIM-UnivAQ/ ServerPyProlog to exchange data between Python programs (or servers) and Prolog programs or Prolog based agents, (if you need to use PHP instead of Python, see ServerProlog: https://github.com/agnsal/ServerDALI/ tree/master/serverPROLOG) – The special startmas startmasMary (https://github.com/agnsal/ ServerDALImas/blob/master/startmasMary.sh) if you need to run the MAS in a Docker container
The MASA (MAS Administrator) (Figure 6) is an agent that supervises the MAS. When an event arrives to Redis Input Channel, the Event Proxy converts it into a standard format and sends it to MASA via the Linda channel. MASA sends it to the proper agent (depending on the configuration) after a second conversion into the format which is accepted by that particular agent; the agent will thus be able to update its KB (Knowledge Base), make inferences and send back its results to Redis Output channel. All internal communication mechanisms are based on the publisher/subscriber asynchronous design pattern, as it is customary in the software engineering community.
The new implementation also enables agents to clean their Knowledge Base from events that are older than a certain threshold (defined in the agent’s configuration files).
We have successfully implemented and tested these functionalities, and we are now experimenting Koine´ DALI ability to allow configuration changes to be made at runtime (the parts under test are distinguished by the violet arrows in Figure 6).
In the new implementation, Koine´ DALI agents work asynchronously (Figure 7) after a handshake, and could therefore be executed in parallel over suitable hardware. The handshake is the first task that a Koine´ DALI MAS performs and it is necessary for the bootstrap operation of the MAS (all the agents have to be operative). MASA delivers arriving events to proper agents and different agents can work at the same time on different events; the resulting MAS is therefore quite efficient. MASA is like the center of a “stellar system” where the number of the agents can vary according to specific needs.
Finally, we can see a little example of a MAS, composed of two agents, the MASA and a normal agent, that are able to communicate with Redis (Figure 9). At the beginning they perform the handshake, then the MASA waits for data/events (i.e. an helloworld event) from Redis and delivers them to the qualified agent (the normal agent, in this case). The competent agent reacts to the event by sending its result to Redis. (a) Agent Type MASA (b) Agent Type Normal Agent Fig. 8. Little example of a Koine´ DALI MAS Prolog code (Koine´ libraries inclusion has been omitted) 5.1
Redis, the communication interfaces for ROS, YARP and MQTT subsystems The inclusion of the Redis channels into the software architecture as internal and external communication allowed us to build several technological plugins oriented to the application domain, in this case robotics. We started with ROS, YARP and MQTT plugins to cover a large range of hardware devices nowadays available on the market.
ROS (Robot Operating System) 3 “provides libraries and tools to help software developers create robot applications. It provides hardware abstraction, device drivers, libraries, visualizers, message-passing, package management, and more. ROS is licensed under an open source, BSD license”.
YARP, Yet An other Robotic Platform, [
MQTT is a machine-to-machine (M2M)/“Internet of Things” connectivity protocol. It was designed as an extremely lightweight publish/subscribe messaging transport. It is useful for connections with remote locations where a small code footprint is required and/or network bandwidth is at a premium.
As said before, a Koine´ DALI MAS can communicate via Redis, sending and receiving messages (consisting of strings) through its ports. This mechanism is very similar to ROS, YARP and MQTT technologies, so we have been able to develop libraries that will make it possible to create a communication between Koine´ DALI MASs and these three technologies and in perspective with physical robots.
The code snippet in Figure 10 copes with listening and publishing on Redis channels only; however, Redis can provide complex data structures as well, so for instance we could store strings in a FIFO queue and extract them from there as needed (from both the MAS and other technologically different components). We have been been able to deploy Redis compatibility libraries for ROS, YARP and MQTT, in order to make Koine´ DALI MASs able to control robots.
This example of YARP in Python/DALI shows how similar its behavior and Redis’ one are. The program, typically embedded onboard a robot, generates raw data and sends them to the YARP port “/sender”. This port could be connected to a “/receiver” YARP port by means of a channel configurator. Then, a Python program could register itself as the handler of the “/receiver” port, thus translating the data into a Linda tuple space, like shown in Figure 3. 6
As we have since long been convinced of the potential usefulness of the DALI logical
agent-oriented programming language in the cognitive robotic domain. In [