Wednesday, August 8, 2012

To tackle Complexity we need to Simplify

This is second installment in the series of posts related to Reactive Agents. The first can be found here:

When the scientific community began work on autonomous robots and artificial intelligence, it ran into a very large obstacle – the world is complex. As it turns out, the best model of the world is the world itself, and we lack the ability to describe it in any form that computers can execute.

With all of our technology for planning, learning, natural language processing and other AI techniques, early robots were very unimpressive creatures. And while a lot can be attributed to the hardware platforms and sensors that we used, the main problem was (and remains) that deduction is slow and complicated!
Even today with all the advancements in hardware and sensors like LIDAR, vision and GPS – robots are still primitive. All the military drones we see and read about are nothing more than remote controlled toys with the over horizon control capabilities, where all the real intelligence is coming from the human operator.
To tackle the complexity problem Rodney A. Brooks proposed that Artificial Intelligence should not be an attempt to build "human level" intelligence directly into machines. Rather, citing evolution as an example, he asserted that we should first create simpler intelligences, and gradually build on the lessons learned from these, working our way up to more complex behaviors.
Brooks’ architecture was designed to provide all the functionality displayed by lower level life forms, namely insects. Using a common house fly as an example, Brooks claimed that creatures with this level of intelligence have attributes that resemble closely connected networks of sensors and actuators, with pre-wired patterns of behavior and simple navigation techniques – they are "deterministic machines".

For the software savvy people reading this, the key concepts present in Brooks’ architecture are that:

  • Intelligent behavior does not require explicit representations – we don’t have to model the world to build an intelligent system
  • Intelligent behavior does not require abstract (symbolic) reasoning – our systems don’t have to think to be intelligent
  • Intelligence is an emergent property of certain complex systems – at some level of complexity systems will become intelligent

We can use Finite State Machines to model the behavior of individual system participants
The architecture provides these capabilities through the use of a combination of simple machines with no central control, no shared representation, slow switching rates and low bandwidth communication. Putting this into modern software system jargon – it’s like many simple computing cores in a massively parallel configuration, each running a Finite State Machine.

Reactive agents are the building blocks of such architecture:
  • They are situated in the world – they are instances and not classes, they are things
  • They interact directly with the world through sensors and actuators – there are no layers, implementation uses direct connectivity to minimize reaction time and implementation overhead
  • They can also interact directly with each other – this interaction is not different than their interaction with the world
A system of reactive agents exists with no overarching models and agents have no knowledge of other agents. Reactive agents simply have to process all incoming signals and based on their internal algorithms and their internal state optionally set outgoing signals.

iRobot’s Roomba is a modern example of a robot using this technic. We can easily identify reactive agents that:

  • Stop the motor and back out when the bumper sensor is triggered
  • Signal the robot to find the charging station or go back to work based on the battery sensor
  • Navigate robot back to the charging station using light beacon when charging is required
Software systems in general and manufacturing systems specifically are complex and suffer from the same problems that exist in robotics and AI software. When we developed Catalyst Platform, we used the very best concepts from reactive agent architecture and functionality, and translated them into a comprehensive solution for event-driven, reactive agent-based software development platform. In the next installment I will cover how our patented technology translates reactive agents from the world of robotics into world of distributed software systems.