School of Computer Science

Distributed architectures for implementing tasks on humanoid robots is a design challenge, both in theory and practice.  Although important functionality resides within the component modules of the system, the performance of the middleware –  the software for mediating information between modules –  is critical to overall system performance.  We have designed an architecture serving various functional roles and information exchange within a distributed system, using three different communication subsystems: the Cognitive Map (CogMap), Distributed Operation via Discrete Events (DiODE), and Multimodal Communication (MC). The CogMap is implemented in Psyclone, a framework for constructing large AI systems, and allows sharing and transformation of information streams dynamically between modules. DiODE provides a direct connection between two modules while MC implements a multi-modal server that streams raw sensory data to requesting external (off-board) perceptual modules. These have been implemented and tested on the Honda Motor Corporation's ASIMO humanoid robot. To identify trade-offs and understand performance limitations in robots with distributed system architectures, we performed a variety of tests on these subsystems under different network conditions, operating systems and computational loads. The results indicate that delays due to our middleware is negligible compared to computational costs associated with actual processing within the modules, provided a network with high enough bandwidth. The Cognitive Map appears to be scalable to an increasing number of connected modules with negligible degradation of package delays.

The Cognitive Map robot architecture is used to build multi-agent systems where components can communicate with each other using a publish-subscribe mechanism of message passing. Messages can be sent as discrete events or via continuous data streams. Our approach of isolating the component interface within a single API layer allows easy conversion of legacy code into components within our system. Our components can be divided into four main roles: perception, knowledge/state representation, decision-making and expression. Interaction, Task Matrix and Multi-Modal Communication are special components described for facilitating human-robot interaction with Honda's humanoid robot ASIMO. By focusing on the design of these components and the abstraction layers between them, our architecture can be dynamically reconfigured to handle different applications with minimal changes to the entire system.

We present a methodology for designing and implementing interactive intelligences. The Constructionist Design Methodology (CDM) -so called because it advocates modular building blocks and incorporation of prior work -addresses factors that we see as key to future advances in A.I., including interdisciplinary collaboration support, coordination of teams and large-scale systems integration.

Four principal features of autonomous control systems are left both unaddressed and unaddressable by present-day engineering methodologies: 1. The ability to operate effectively in environments that are only partially known beforehand at design time; 2. A level of generality that allows a system to re-assess and re-define the fulfillment of its mission in light of unexpected constraints or other unforeseen changes in the environment; 3. The ability to operate effectively in environments of significant complexity; and 4. The ability to degrade gracefully – how it can continue striving to achieve its main goals when resources become scarce, or in light of other expected or unexpected constraining factors that impede its progress. We describe new methodological and engineering principles for addressing these shortcomings, that we have used to design a machine that becomes increasingly better at behaving in underspecified circumstances, in a goal-directed way, on the job, by modeling itself and its environment as experience accumulates. Based on principles of autocatalysis, endogeny, and reflectivity, the work provides an architectural blueprint for constructing systems with high levels of operational autonomy in underspecified circumstances, starting from only a small amount of designer-specified code – a seed. Using a value- driven dynamic priority scheduling to control the parallel execution of a vast number of lines of reasoning, the system accumulates increasingly useful models of its experience, resulting in recursive self-improvement that can be autonomously sustained after the machine leaves the lab, within the boundaries imposed by its designers. A prototype system has been implemented and demonstrated to learn a complex real-world task – real-time multimodal dialogue with humans – by on-line observation. Our work presents solutions to several challenges that must be solved for achieving artificial general intelligence.

Systems intended to operate in dynamic, complex environments – without intervention from their designers or significant amounts of domain-dependent information provided at design time – must be equipped with a sufficient level of existential autonomy. This feature of naturally intelligent systems has largely been missing from cognitive architectures created to date, due in part to the fact that high levels of existential autonomy require systems to program themselves; good principles for self-programming have remained elusive. Achieving this with the major programming methodologies in use today is not likely, as these are without exception designed to be used by the human mind: Producing self-programming systems that can grow from first principles using these therefore requires first solving the AI problem itself – the very problem we are trying to solve. Advances in existential autonomy call for a new programming paradigm, with self-programming squarely at its center. The principles of such a paradigm are likely to be fundamentally different from prevailing approaches; among the desired features for a programming language designed for automatic self-programming are (a) support for autonomous knowledge acquisition, (b) real-time and any-time operation, (c) reflectivity, and (d) massive parallelization. With these and other requirements guiding our work, we have created a programming paradigm and language called Replicode. Here we discuss the reasoning behind our approach and the main motivations and features that set this work from apart from prior approaches.