Architecture of Emergence & Memetics, Part II

Here’s a core concept of my emergence engine: model based evolutionary value creation. Basically it means the following:
- You get stories depicting some domain, i.e., user answers or tweets
- You translate them to semantic concepts & statements
- You give these concepts & statements (model parts) behavior, which basically tries to create value for the end users, or the end users organization
– Simplest example is when some statement can bring value to some user if he learns about it
– Another example is when several statements reason the causal relations between them & infer what is the root cause to some phenomenon
- Having all of the model parts behave all the time is compute intensive, which has a cost
- Not all of the model parts have the potential to create value
- So, an evolutionary process can take place, in which only the model parts that succeed in creating value survive & get resources.

See also my initial post on the base concept.

 

Architectures of Memetics & Emergence (part I)

Motivation: autonomous value creating applications

I’ve been working on a very pretentious platform which I hope can prove useful for innovative applications. The platform is based on 2 main principles, Memetics & Emergence. Both are originally taken from the world of human culture & sociology. In the architecture of this platform they are applied to a complex composite Multi Agent System. The motivation behind it is to try mimic the way human individuals, organizations & societies succeed in very large complex tasks, whereas it be a single human, small team, business corporation or a whole society. The fact is that a single human, or any organization of humans is usually good in doing something, called Creating Value. The fact that I earn money is because I create value for my employer; the fact that some company makes money is because it creates value for its customers. So the general motivation for an architecture that tries to mimic human or human organization is to enable software to create value. It isn’t that existing software today doesn’t create value, the only reason software exists is because it creates value. But, unlike software, humans aren’t (explicitly) programmed – they are given some initial knowledge (education/training), they are assigned some jobs, & they create value while collecting the knowledge & expertise in doing it. And this is the motivation. A task such as enabling applications to create value without being programmed seems complete Science Fiction today. So we require something very novel & innovative & something very new to basically be able to claim that we can build such applications, that create value without being programmed, except for some basic education: when assigned with a job, performing it, improving in it & creating value without being specifically programmed as to how to solve each case. The motivation is to create software that just like Humans, even when provided only with basic knowledge of what to do in each case, still can:

• Solve unexpected situations,

• Create value in unexpected ways,

• employ both common sense &

• the ability to learn from situations &

• improve its performance, i.e., the value created,

• by merely performing the job for sufficient amount of time.

 

Memetics & Emergence

So, what are the architecture components that we claim may produce this?

Let’s start with Memetics. Well, memetics basically is the theory that there is an evolution of ideas, where ideas are taken in the broadest sense of things that you copy/learn from others. This evolution is for what is called human culture, science, art, & basically our whole social life is based on memetics. For an ultimate introduction to Memetics, I highly recommend hearing or reading the proponent of this field, Dr. Susan Blackmore. This is the basic idea. This idea can apply not only to the humans world, but also to general intelligent agents. When applied to software, Memetics basically means Evolutionary Knowledge Engineering. The idea is that whereas in knowledge engineering we produce knowledge representations of a domain, including also knowledge required to perform tasks, i.e., Behavioral Knowledge, in Evolutionary Knowledge Engineering, we apply the evolutionary algorithm to this process of knowledge engineering. Meaning that, if we have variations of knowledge representations & if we have different versions of how to perform tasks, only the fittest of these pieces of knowledge will survive & be the base of the knowledge base population. The effect of this is improvement in our knowledge, which becomes more adapted & effective in it’s domain environment. So, to recap, memetics is all about people spreading ideas, & the ideas that are the fittest – most fruitful & valuable – are the ones that survive & base the population of ideas. Similarly, Evolutionary Knowledge Engineering is just Memetics applied not to the culture of humans, but to any society of agents performing knowledge engineering.

 

 

The 2^nd concept called Emergence, is basically a claim that high-level intelligent behavior can be obtained from low-level simple agents, whether it be animals, software or any object with some behavior, when you combine them into a group, that works together. So any time you take a bunch of agents & combine them into a group, even though each of them has a very simple low level behavior, that may not present any intelligence whatsoever, i.e., any complexity, any reasoning behind it, nevertheless, when you combine them into a group, that works together & collaborate, suddenly the group has an higher-level intelligent behavior, in other words, the intelligence emerges from nowhere, by just combining the agents into a bigger unit. For a great introduction to this concept, with numerous eye-opening examples, I highly recommend reading the book on this concept, by Steven Berlin Johnson. Normally, we think of emergence in situations when the intelligent behavior emerges unexpectedly, but I prefer to include any high-level behavior formed by the collaboration of lower-level parts. E.g., a Power Ranger has this amount of power, but when a team of Power Rangers connect together & morph into a giant all-mighty robot, I also see it as emergence. Now this of course may recurse, for example, if you take a group of A-type agents, & combine them into a group, called B-type, & then combine several B-type agents, into a group called C-type. Now the C-type agent can then manifest even higher level of intelligence than B-types agents, & this is like multiplication of the power of emergence, because we start from simple very low-level unintelligent A-type agents, & multiple the emergence effect & get C-type intelligent agents.

Illustration of emergence: combination of many simple pixels into a group, creates complex intelligent picture (Original image by Matt Champlin)

And another illustration: it’s hard to model a 3D shape, e.g.:

 

But if you zoom to a much lower level, you can model the shape, e.g., using many simple triangles:

 

Emergence examples are all around us, everywhere you look, & it’s enough to mention the extreme intelligence (learn & behold) of Ant colonies as a very obvious example. Each ant doesn’t manifest high-level intelligent behavior, but when you combine them into a group, you get a very powerful & successful intelligent behavior. Ants are a very good example, but if you think about it, take any group of humans, whether it be a family, team, community, organization, city, nation, any group of people, is strong because it has more intelligence & more power, that is ability to solve large problems (i.e., Intelligence), only by combining individuals into a higher-level group. In corporations, or hierarchical organizations, we see the emergence multiplication effect, where we take several people into a team, & then take several teams into a department, & then take several department into a division & so forth, we see that more power & more intelligence, more high-level behavior, come out of the group as we multiply the emergence effect. We must understand that it is not the sum of power of the individual components. Take for example a branch of a fast-food chain. The power & intelligence of it, isn’t the sum of the power of the staff running it. The added power & intelligence of these workers isn’t enough to feed thousands of people each day. These young people don’t necessarily understand the process & knowledge, & the sum of their intelligence isn’t enough. Put them all in a room, & you get no special intelligence & power to feed many people. The intelligence is in the fact that working together they create some higher-level machine. They create something that is very powerful, feed thousands of people, but it is not the sum of their intelligence & power. The intelligence is in the combination of them into a collaborating team. Everyone are doing their low-level job, & you get a very powerful higher-level machine. Once they combine you get the emergence effect. Suddenly a bunch of teen-agers feed thousands of people. (This is just an illustration, please don’t take it personal if you happen to be a teen working in a fast-food branch…)

 

 

You could say that both Emergence & Memetics, are nothing but metaphores, ways to see things, which humans have always known. But as any science theory is just a way to see stuff, judged by its fruitfulness in predicting measurements, I believe with these concepts you understand how come human ideas & knowledge improves all the time, & how come the teaming of humans into special types of groups yields so much power, & once you understand it, you can harness this in human life, to create new types of mechanisms, for example as the social services harness the concept of emergence, file-sharing networks, Web2.0 social services, all exemplify it in numerous examples. You can also harness these principles into architecture of software agents, which is what the platform I’ve been working on is all about.

 

Illustration of a simple composite architecture based on Memetics & Emergence

 

 

Engineering decentralized multi-human value vending machines

I’ve been working for a few years on Knowledge & Emergence Engineering, combined also with Machine learning, & am very excited to prototype engines based on the synthesis of these technologies. What these technologies enable are new types of adaptive & autonomic information systems, capable of delivering value without programming & maintenance. It only needs to receive initial common-sense & domain knowledge, including the knowledge on how to create & engineer value, & from there it goes on by itself to pursue its goals, & constantly improve its effectiveness. Really exciting.

Now, one of the types of mechanisms that could benefit from such engines, are a new kind of social mechanisms, that dynamically bind humans & computers into economic machines, i.e., decentralized dynamic companies.

Such companies exploit the powers of both carbon & silicon based agents, & are glued together by the management mechanism implemented by the emergence engines. Think Amazon Mechanical Turk, but with a learning automatic managers, constantly working (without human intervention) on driving end-to-end business processes.

Such mechanisms could eventually leverage the unexploited time & intelligence of many unemployed human population, without requiring special knowledge or initial expertise, & help them make money. Normally, their common-sense & social knowledge will be enough to achieve their queue of tasks, automatically assigned to them by the managing engine.

I don’t have enough time to play with these engine, in the required amount, so I can’t promise anything. But I’ll most certainly be happy to get rid of the exploiting-evil & overhead of millions of human managers, that could efficiently be replaced by automatic mechanisms, for the benefit of their poor subordinate egg-heads.

 

Test case for yielding emergence

I was thinking on the simplest way to test my emergence engine, & came up with an extremely simple task – the reactive algorithm of a thermostat: measure the temperature, & turn the heating on & off to maintain a given temperature. It sounds indeed very simple to code a program that does that, but what I’m going to experiment is how to do it without any programming.

Emergence engine is a kind of general AI, capable of achieving goals, without being programmed how to solve them. It’s based on the assumption that you don’t need to build real intelligence, rather just create many many simple software workers, having only very simple tools & logic, & let them swarm their way toward the system’s given goals.

So, here’s how I hope my engine will handle the test case:

• It should 1st learn by elicitation the model of a room, having a temperature, thermometer & heating unit.
• It should also learn the relevant beliefs on the effect of using the thermometer on the accuracy of the model, & the effect of turning the heating on & off on the room’s temperature
• It should then learn what’s the desired temperature
• From this it should start deriving action plans & execute activities to achieve the goal of maintaining the desired temperature
• It should also adapt to changes in the room, e.g., a door is open & there’s need to use more heating, or alternatively the heating doesn’t work & we need an alternative heating unit

I’m saying it but of course what’s doing all this are many collaborating agents, working together to achieve the goal. This is done by breaking the value in the goal into smaller value “summs” given to states & activities leading to the goal, & having the agents collaborate on creating all these summs.

Although the design is very simple, & intended for complete autonomous behavior, I noticed that I’ll be able to effect the engine & help it reach its goal, by changing the knowledge driving it, i.e., the learnt beliefs, according to which the agents work.

So, I can’t wait to see how the engine will handle this, which will actually test whether the simple emergence design is enough to yield emergence, even if the value it delivers is so small & simple.

 

How-to: connect to protégé server from your app

I couldn't find any documentation on how exactly to do this, so here's a sample code:

        ArrayList<String> errors = new ArrayList<String>();

        Project project = RemoteProjectManager.getInstance().getProject(kbHost,
                          kbUserName, kbPassword, kbName, true);
        if (errors.size() > 0) {
            for (String s : errors) {
                log.error(s);
            }
            throw new InitException("Failed to connect to the Knowledge Base");
        }
        knowledgeBase = project.getKnowledgeBase();

[They didn't provide documentation, but you can still digg their unit tests...]

 

Knowledge syndication

I got as a b-day present 2 great books, one is the must-read On Intelligence, & the other is a billingual collection of Confucius sayings. As there are many knowledge extraction posts on the 1st, e.g. Robert Burke's, but less of the 2nd, I decided I must share with the world the wise Confucius knowledge as a Listible list (the other option was a Moodle course on my homepage).

Then I saw in the browser status bar that my NetVibes tab is busy reading (RSS) content from various great web sites, & it suddenly hit me that instead of me listing Confucius sayings in this location, & Robert Burke listing Jeff Hawkins sayings in that location, what's needed is a standard format for syndicating knowledge beliefs. Not just pure knowledge, domain coneptualization as in the Semantic Web, but practical behavioral knowledge, executable specification, that can be used by beliefs-based engines to acheive goals.

I made recently an architecture of such an engine, that is driven by goals & an inventory of beliefs, but didn't thought about the idea that the inventory of beliefs would be the whole web, or at least what's encoded in the NSSKS format (Not So Simple Knowledge Syndication…).

Maybe it's just a subset/dialect of OWL, but with proper beliefs-based machines, it could be something very powerful. Then we'll need also standards for Goals syndication, & the agents will become completely autonomous, doing the work for us without any need to tell them what, when & how to do it.

 

Early adopters of the world: Use OpenIRIS!

I read a few years ago about the DARPA CALO project (Cognitive Agent that Learns & Organizes), or was it the PAL project (Perceptive Agent that Learns)? Anyway, I was quite amazed, because I was thinking back then about similar architecture & technologies. Well, about a month ago, they decided to actually ship the technology, & open its source!!!!

It's called OpenIRIS (http://www.openiris.org/), & it's a "Semantic Desktop", in which you work on your applications (Browser, Mail, Chat, Calendar, Tasks, Documents &c), & behind the scenes everything is analyzed & organized in a beautiful ontology (!!!) that enables you to "Integrate. Relate. Infer. Share.".
DARPA just paid researchers from some 22 universities, to actually go & implement the semantic technologies that have such huge promises, using today's paradigms & technologies.

I've started playing with it a few weeks ago, & today decided to actually use it. Well, I'm holding my hands from evangalizing (except for the post's title), but I'm quite impressed from the result! There are some small problems, & the giant platform is slightly slow, but the basics seem to work – some giant OWL-based ontology is being accumulated behind-the-scenes, & used for integrating the information. (One thing does annoy: I hope they'll switch to FireFox (instead of the old Mozilla), because I can't use a browser without my extensions…). I might even try write a plug-in for FreeMind or some other app I can't live without, & see how it works.

Thanks DARPA, SRI & all other researchers for bringing the future closer!

Update: Oops! There's only a Windows version … Seems like I won't be using it much, coz my primary OS is Linux. (hey, please spend the last mile effort for the sake of Linux & MacOS early adopters…)

 

Imagination-Bases

Data-Bases describes the data of the existing world, i.e., the empirical recording of facts, used for machines that were programmed to process the world.
Knowledge-Bases describe the existing world, i.e., the ontological knowledge transfer required for machines (or aliens) that need to sense & affect the world.

Imagination-Bases describe possible worlds, i.e., the simulation of potential future worlds, that humans & machines can build & live inside.

IB’s require the same knowledge representation facilities as KB’s, but also Simulation facilities & the sensual-stream generation capabilities.

There are some interesting IB projects (spring-alpha, second-life), but too bad we don’t have the legendary Imagination Engineers of the past, such as Jonathan Swift.

“Imagination is more important than Knowledge” (Albert Einstein)