Well, guess again, whilst I am all for the increase in user interaction on websites, and user generated content. Whenever I hear "Web 2.0" or something based off the term (eg. Gov 2.0) I cringe… In fact, a little part of me dies. And here's why…

For those who are new to my Blog, my name is Owen, and I work as an IT Officer for the Faculty of Information Sciences & Engineering at UC.

I'm 21 years old, which places me well and truly as a member of Gen Y. I do many stereotypical things that are associated with our Generation. I blog, facebook, love fast internet and real time status updates, and have many many tech devices integrated into my life. My phone, of course is rarely away from my side. Along with these, I multitask alot – often with a multitude of tabs and windows open on my desktop, several books I'm reading scattered around my desks. My desk is arranged to support the functionality of my workstation. On one desk I have two widescreen monitors arrayed at the back to my main PC, a secondary PC with a monitor hooked in on the left, and in front of it all is another widescreen which is often used to extend my laptop. Along with my laptop, I have an eee PC, and a PDA. And on the Phone side of things I also have a blackberry…

Why am I telling you this? It's to show you my association with "Gen Y", of all the people to take a dig at something that is A-Typical of Gen Y, surely it is a member of it.

I would actually like to add another term to our already term-saturated generation… and that is the "Slogan Generation". Everything needs to have a slogan, a buzzword, something that picks up our ears and grabs our attention. Political figures adopt slogans in order to sell themselves to our generation (Kevin07), social justice groups create catchy slogans to get people in on their aid events, and we even now have a slogan slapped on the internet to make it sound hip and new and exciting… and quite frankly, on this last point, I am sick of it.

Web 2.0

Firslty, what is Web 2.0?

• The term "Web 2.0" is commonly associated with web applications that facilitate interactive information sharing, interoperability, user-centered …
  en.wikipedia.org/wiki/Web_2.0
• The second generation of the World Wide Web, especially the movement away from static webpages to dynamic and shareable content and social networking
  en.wiktionary.org/wiki/Web_2.0

I would point out several interesting points. The domain of the term is in the area of "web applications", with a general movement from static to dynamic content and social networking. It focuses on the end output, and ability to interact as opposed to the underlying architecture.

So that's Web 2.0, what then was the first generation of the Web? (Google define – downloaded 1:15 PM 7/6/2010)

• network: an interconnected system of things or people

• World Wide Web: computer network consisting of a collection of internet sites that offer text and graphics and sound and animation resources through the hypertext transfer protocol

A quick glance at Wiki gives us a few more pearls of wisdom; Speaking of the initial proposal by Robert Cailliau for the web:

This proposal estimated that a read-only web would be developed within three months and that it would take six months to achieve "the creation of new links and new material by readers, [so that] authorship becomes universal" as well as "the automatic notification of a reader when new material of interest to him/her has become available."

Interesting – "The creation of new links and new material by readers, [so that] authorship becomes universal". The web would intrinsically be a socially generated and driven medium. This proposal was put forward in 1990. Wiki then suggests that the latter have only just found fruition in the forms of Web 2.0, and RSS. For the latter, I agree partially, but on the prior, I think such a jump is unwarranted.

From the very early days of the internet, it has been fairly easy to set up your own website. I did my first way back in primary school. This was socially generated content – was it not? Of course, I had very little skills to do much more than simply a static page, but already the web was there, ripe for the picking. I could embed things such as pictures, videos, and sound effects, I could even do some tricky scrolling fonts if I was particularly on the ball. As the years progressed, very few things have changed to that initial functionality of the web, except for one thing. The major movement between the internet's infancy and now is NOT found in it's social focus, and is NOT found in it's user generated content, the major movement has been in the EASE of generating that content.

Sure, the languages have changed, there are more tools available to create and generate content, and they are now more flexible in the way that they allow you to present that content; But nowhere is there a sufficient change to claim that there has been a substantial shift in what the web essentially is.

The capability has always been there, it has merely taken time for us to discover that it is there and usable. It started with comment pages, and forums, and has now developed into things such as facebook and yammer. This latest buzz word of "Web 2.0" is useless in picturing anything of the reality of the web. From it's very infancy it was about social interaction and connectivity, and now people are discovering that is to such a point that they can interact and connect using the web, with limited expertise and knowledge and so ARE connecting using it.

So what do you guys think – Hot or Not? Is Web 2.0 all it is cracked up to be, or is it merely a buzz word for the masses?

- Owen

So I thought it was about time that I posted an update to the blog summarising the research I've been doing up until the latter part of last year.

Some of the things I've been up to have finally found a conclusion. For example, I received my result back for the subject I was doing on Soft Computing, a HD, which was an outstanding result that I was very pleased with. I put alot of time and effort into learning and using the various Soft Computing techniques in order to build my projects.

In terms of current research, I have had a number of projects up my sleeve.

One of the key ones is that I have been writing and building a Fuzzy Logic library. It frustrated me no end that I did not have a prebuilt module which I could slip into my agent programming. So, over the past few months, I have begun working through the code structure for a C# implementation of Fuzzy Logic. Fortunately, I'm not completely writing it from scratch. I'm basing the structure roughly on the base functions that one of my lecturers had used for an implementation in a different language. However, I only have the headers for the function calls and the rough outline for what each function does, so part of what I have been doing is researching what the best methods for doing various operations on Fuzzy Sets are… and how many of these I should include in my implementation.

The benefits of such a library are numerous. As I said earlier, I was working with agents and wanted to be able to use Fuzzy Logic in its decision system. This would have majorly simplified the project. In the project, I ended up using a matrix of numbers to simulate a bit of what a Fuzzy Logic system could do – but then it was limited, in that I had to instead place greater emphasis on my deductions. These too, also had some aspects of Fuzzy Logic, in that I was accumulating ranking values in order to determine the best of four scenarios. Still, this was far from simple.

The other big project I have been working on (although it may be dependent on the Fuzzy Logic library to be finished first!) is an Evolutionary simulator.

This is an interesting one, in that I am building a terrain, and placing creatures into the world. The creatures not only have to learn about the environment, but must be able to learn about themselves as well. I'm seeking to pack the creatures with only minimal knowledge in order to learn, and deduce. They have to be able to figure out what each of their components is able to do, and how that component may be used. On top of this, the simulator is further complicated by the fact that the creatures may kill, or breed. I'm still thinking through the best way to implement this, but it poses an interesting problem.

How should one define the relationship between two creatures? How will they develop relationships? Should they be on something arbitrary? (eg. they're the same colour, therefore they are rivals, thus they will attempt to eat each other) or should it be on something random? Or perhaps it is based on what they are doing at the time of their meeting (eg. if one creature was eating the others food then they are rivals)

Or the more interesting situation would be – if the creatures could define their relationships themselves – why couldn't any of the above be used?

Hopefully it won't be as long to my next blog – certainly, there are alot of things I am working on at the moment which may interested some of my readers.

Regards,

Owen

One of the problems that the model presented in my last blog post faces, as it was presented to me by Robert Cox this morning, is that the system would have trouble handing invalid or incorrect data. When the training is not a series perfect solutions, then our system could potentially build up a less than optimal solution…

How do we handle this?

You will recall that I was considering the benefits of having each point handled as a object rather than simply just a piece of data. This gives us a great flexibility as to how we deal with the diagrams. We can actually add an extra modifier to our objects – that being an accuracy or uncertainty factor.

Let’s consider our 3 Dimensional model we were using earlier. If we were to add a whole heap of points in a very localised area, they would provide affirmation… but if these points are less than optimal, we would not want our system to be trained to produce the solution. This is where our accuracy or uncertainty factor comes in. This means that if we have a small space of very mixed data then we could request the system to assess whether the uncertainty of that region, using the uncertainty we could use our existing areas of influence to create a map of the certainty of certain areas. A lower certainty, the lower that area will output to our result sets. If a area is sufficiently uncertain, then if we are in the testing stage, we could request the system to perform it’s test, to compare the different potential of each situation.

Of course, when changes can be counteracted by others later on, we may be unable to get a clear assessment of what was actually a successful or unsuccessful change. In this case, we can instead ask the system to firstly seek more suitable alternatives, and if none can be found then to take the modified potential of our fuzzy set. Taking both the standard mapping of our point to the fuzzy set, but also applying the uncertainties of the area.

The picture I have in my mind about these situations is somewhat like a series of topological maps. You can download maps which show different aspects, rainfall patterns, ground conditions, area boundaries, heights etc. In the same way, I think we can adapt our fuzzy system to be amazingly intuitive as to how it deals with different scenarios.

Also, during our testing stage, we could ask our system to create a test case. To have two situations which are identical. Every input stays the same no matter what happens – a control case. As we provide more of these to the system, it can test the different possibilities and the subsequent results. As we apply these test cases we would need to allow them to accumulate data, but also to assess the scenario and look at the input… what if we change one input slightly? The system needs to develop fuzzy concepts of what is happening, so that it knows when to respond and at what stage it will need to respond.

In fact, perhaps mixing it with different genetic algorithms during the training stage would be beneficial – particularly since human beings rarely have the optimal solution themselves – particularly in the realm of computer games and strategies. Such adaptation by the AI would be particularly useful in scenarios when there a variety of different prospective strategies that could provide equally useful results.

Hmm…

Whilst it is less complex to rely on a 2D fuzzy set, the limitations of such sets are fairly big. For example, we could plot two fuzzy sets simultaneously to create a joint graph, but then the implication is that the two sets will be consistent across our 3D space. We could instead, have a series of fuzzy sets defined at intervals across our 3D domains… but that would require alot of extra work in order to create something of relative simplicity.

Let’s think of a simple case for the time being.

My domain is x, z, and [0,1] on the y axis.

I do not necessarily have a consistent x set, or a consistent z set so it would be counterproductive to map them against each other from 2D sets.

So instead, we’ve created a 3D space on which to work with. Let’s make the domain of x = [0, 1000], and the domain of z = [0, 2000]. Now, to add a point to this space we need to define a few things, as with a 2D fuzzy set, we must firstly set the default state, in which case, let’s declare the corners {0, 0}, {0, 2000}, {1000, 0}, {1000, 2000} to have the truth value of 0.

Now, let’s add a few points, the syntax I shall use is {(truth value – eg. y), x, z}, {(1), 0, 500}, {(1), 500, 650}, {(1), 300, 50}. As it stands, these points appear as anomalies. The reason being, we have yet to define exactly how these impact our space other than simply being a floating point. To refine our example a bit more, we define our margin of error. This is the level to which we want any intial point to have scope in the area. It defines the slope of our curve, which I think would be "somewhat" in thinking about 2D Fuzzy Hedges. Let’s set out margin of error at 5 (we could define them differently for different axis, but for the time being I think that would be unnecessary, and you could also include refinement in terms of sample rates to increase or decrease speed of calculations). With our margin of error, we draw a circle around our point with a radius of 5. Sampling at every 15 degrees for simplicity. From each sample point on that circle, we draw a line from the "0" default truth value, and up to the truth value of our point (in this case 1). Then for each of those lines we apply the hedge "somewhat" and we get a hill like shape on our set.

Some things to note at this stage, we have 3, seperate, independent fuzzy areas defined. You could use a different hedge for the slope depending on the various application you are using. In fact, you don’t need to use a hedge at all, but graphically the straight lines would look boring

Something to think about at this stage is what the "area of affinity" or "area of gravity" will be on our set. If the affinity of an object is high, then it will have a larger impact on surrounding sets, the larger the "area of affinity" is then the more sets will be included in its impact of such an affinity. This becomes important when we are teaching a system. If we were doing data analysis, and we were thinking about how probable a certain situation is, the more cases that have proven to be true in a specific area, then the probability that the result is accurate would go up.

Also, as we are constructing our set, it is important to note that a point, and its subsequent area are of two different materials. It might be helpful when constructing a system to actually have an originating set with just the points. This is because you may want to introduce counteractive points and other variances. You don’t want to lose data, and having counteractive points may mean that any level of affinity could be broken, and so a single point would no longer benefit from it.

In my thinking, I’m also beginning to handle points more as objects. This becomes particularly useful when you want to have different impacts, or logs for each point. Let’s say we add a counteractive point, we could remodel our entire domain in order to seperate affinities, but that may not be necessary, instead we could look at the area of our counteractive point and grab any point in its impact area. Looking at the point we can see the log of which affinities it has benefited from, and then we simply need to look at whether our counteractive point is situated in a way to detriment or nullify that affinity. By handling the points as objects, you would no longer need a secondary domain with just the points on it, because each object would include its original value, thus maintaining our data integrity.

Also, by handling points as object, we can have different descriptions and consequences for each point, rather than being limited to the generic description included as the definition of our fuzzy set.

What do I mean by "counteractive points"?

Well, there are several different types of impact, in my mind, that a point and subsequent area can have on other points.

There is a counteractive point: A counteractive point is one that counteracts an affinity of another object, or reduces the impact of another object (eg. may decrease its truth value)

There is a independent point: This point has no impact on surrounding points or their areas. It is taken at face value and not influenced by others.

There is a mutually beneficial point: This point benefits from other surrounding points and their affinities as well as granting benefit to them as well.

There is a leech point: This point takes any influences to benefit itself, but does not impact the surrounding points.

There is a assistant point: This point can not be improved but still improves others around it.

Having all of the points handled independently, it might even be useful to change how the results of a fuzzy rule are calculated. We can still use traditional accumulators, but we could also use descriptions within each object to present the result that is anticipated. This would be useful in broad domains, but highly inefficient where only a few outputs are expected… or it would be very useful where the domain is not particularly consisted, but there is still only a few outputs to be determined. In fact, we have unwittingly added a fourth dimension, that being what we use to discriminate between different points…

’tis a curious train of thoughts…

Counteractive Rules may, to the first look, seem rather silly, why write a rule in the first place if you must counter it later – doesn’t that tell you that the initial rule is weak?

Well, no, it doesn’t.

The specific rule based system I have been developing is based on Fuzzy Sets and Logic, and seeks to simulate the landing of Harrier aircraft onto a very small point. The problem at first glance seems immense. How can you factor in wind, ship speed, ground effect etc. into a simple program? That is where the beauty of Fuzzy systems comes into its own.

Rather than seeking to write a comprehensive rule set, I began to experiment with default rules, and counteractive rules. To begin with, asking the question, "What is the state I would want the plane when nothing else is firing". Once I had the default rules up I began to counter balance them.

So, the defaults said, I want the thrusters to be aimed down, and a large thrust to be provided for them to lightly counteract (although not totally counteract) its descent.

With that in hand I began to explore what else I would need. The problem seemed complicated in that I was working with two output variables, but as I explored more I realised that I didn’t need to constantly adjust all the outputs – in fact, doing so would cause the system to fail because I would be firing thrusters etc. in ways that would counteract the more important rules.

So, for example, I had a rule that said, once the Harrier gets too low, put the thrust up to full. If I had adjusted the directional vector then it could have counteracted the directional movement, and since the default and all subsequent vectors were aimed roughly downwards, increasing the thrust would always produce a upward force.

We, of course, are landing the aircraft, for our simulation, it was within reason to assume that the only reason the aircraft would move up is corrective. So I made a rule that if the aircraft was moving up, the thrusters should be turned off.

Now, if you are thinking in terms of standard boolean rules where either they are completely true, or completely false, then you are calling me stupid right now… for, if we want to move upward if we get too low, and we refuse to allow the aircraft to move up, then the two rules completely nullify each other… That is true!

However, we are not using boolean rules, we are using rules based on fuzzy sets.

As the aircraft gets lower, it begins to have greater membership within the set of "Low". This set, if we were to graph it, is not False, and at some arbitary point, instantly becomes True. Instead we say ,well, starting at this point, the aircrafts height begins to be low, it may only be slightly low (eg. a membership of 0.1). As it moves further into the set it more fully realises its "lowness". Now, when we go to apply the operation of full thrusters, the thrusters are scaled according to the degree of membership. As the aircraft becomes more fully in the range of our "Low" set, the full thrusters become more dominant, this becomes important when we have counteractive fuzzy rules.

Once it reaches a certain point, the set of full thrusters becomes so dominant that the aircraft begins to slow and then to go upwards. As it starts to move upwards it starts to move into our fuzzy set of "Up". This set is 0 at 0 m/s up and 1 at 1 m/s up, and has varying degrees of membership in between those two speeds. (eg. at 0.5 m/s, it  is 0.5 in the set of Up)

As we move further into the Up set, our membership becomes bigger, and the dominance of our "No Thrusters" that we want to apply becomes greater.

What happens when these two rules fire at the same time? They counteract each other, but not in a dramatic way. Because they are acting on the same output (thrusters) we have the two sets outputing into the same set. To get our thruster power, we take the center of gravity of our set. If the Full Thrusters is the only rule firing then the thrusters go to full, if the No Thrusters is the only rule that is firing, then the thrusters turn off, if they fire equally then the thrusters have a middle value. What happens is the sets balance each other. As one increases the Center of Gravity moves towards it and so it gains dominance. This balances until an optimal movement is achieved, or until the circumstances change. Because the Up set is not fully 1 as soon as it goes up, it depends on the dominance of the other rule, it is still possible to travel up slowly for corrective purposes.

Then comes another interesting point… if we fire our thrusters full when we get too low, how do we land?

We have another counteractive rule. Over the space of 3 meters (of the optimal landing point) we have a triangular set defined. Where 1 meter to the left is 0 in terms of the landing space, and 1 meter to the right is 0, and right on top is 1. When the aircraft hovers over the landing site we kill the thrusters. If it is moving to the left or the right we fire the thrusters at a light angle.

Now, there are some rules which counteract these defaults… We actually want the aircraft to be within the safe landing speeds, so we have a rule that says, when in the landing site, if the aircraft is going any faster than the safe speeds we fire the thrusters full. With our fuzzy sets we can define these in such a way that as they move into the sets they gradually increase in power and dominance so that we don’t have an eccelectic firing sequence.

Furthermore, we define a couple of sets to the left and the right of the landing site so that we can provide some directional thrust to counteract and added movement and to let the aircraft know when we begin to get too close to the sides.

Then we just need a few more base rules, these being, if you are to the left of the pad then angle the thrusters to direct the aircraft towards the landing pad, and if you are to the right of the pad then you do the same.

I also add a few emergency parameters. Seeing as we are landing, we don’t need to be travelling fast, so if the speed goes over a certain limit to the left or right then the ship fires the thrusters in an angle to counteract it, and if it is going too fast down then thrusters go to full.

Whilst the overlap of rules seems a bit sloppy at first, it is essential to the safe and effective working of the system. It allows simplicity which makes the system easy to tweak and to understand. It is interesting in that functional decomposition (the breaking of a problem into smaller bite sized function bites) is very similar in thought to the way you need to approach a fuzzy system. By first dealing with the extremes and by knowing where you don’t need to worry about different outputs, and where you definitely need to override them, you can build your system with a flexibility that is unachievable in a traditional rule based system.
 

As he builds his genetic algorithm, each generation is given a score based on its closeness to the original image. As the program runs, subsequent generations slowly build up until you get an image which somewhat resembles the tree. However, this is a slow and tedious process, depending on the complexity of the algorithm designed (and I watched one slowly attempt to get a good tree), the length of time and the closeness to the original image that is desired.

Surely there would be a way to optimize the program a bit more!

What if, rather than allowing the whole population to interbreed, instead we allow only certain areas of a population to interbreed. Let’s pretend there were a series of different habitats, a desert, an ocean, a forest, and a tundra. Different genomes would be more adept at surviving for in each one. As the population adapts to its own environment it moves towards a more suitable form.

However, we would not want to completely segregate the parts. If we do this we decrease the genetic diversity of our total population and could end up missing our most optimal solution… also, once one part reaches an optimal solution, it stagnates and can’t move.

But what if we do allow movement between the four (what I shall call) competition pools? If we stumble upon a better solution for pool 1 in pool 4, we should include the facility to move that genome to pool 1. If we simply move it, then we would lose it from the original competition pool, so instead, we could do an a-sexual reproduction. The genome replicates itself into the other pool. If the genome is weaker than the other strong genomes in pool 1 it will die out, but if it survives it may bring about a more optimal solution…

In fact, segregating our population in this fashion increases the likelihood that we will end up with the most optimal solution.

Why? Well, when are have a single population, the survivors of that population begin to lose genetic diversity and merge towards what they deem is the most optimal solution that they can… but this might be a local minima.

(think of a wavey line, a dip could be a local minima, if our algorithm finds that minima, it may get stuck in it because it does not want to shift to the left or the right because the line’s level rises – assuming, of course, that that the lowest point is the most optimal).

If, however, there is another population which is attempting to optimize something else, it may chance upon a better minima for a different pool. This genome then is transfered to the other competition pool to see whether it in fact is better. If it survives then that pool will continue it’s optimization, if it dies then there was no harm done to our most optimal solution anyway.

In fact, one might suggest creating a small population around that newly found minima so as to allow a chance for the population to survive. - this is something I am considering quite closely, as to its the benefit, and how it would be done in order to allow it optimize itself before being put into full competition

Going back to our tree example, we could segregate the image into four parts. Each generation is a complete tree, however, in terms of construction of the tree, each genome may only be fighting against opponents in one quarter of the total genetic pool. Once Alleles start to disappear we can begin to see our tree take some obvious shape and characteristics. Once our optimals have been reached, we can create a new competition pool, taking a portion of genetic code from a genome in each pool, corresponding to the portion that was successful, merging the pools and allowing them to optimize into the best possible looking tree.

Some food for thought! Hopefully in the not-so far future I shall have the opportunity to use this technique on some actual AI (probably in a game of some descript) to see the benefit that it brings about.

But for now, I better continue working on my assignment – an AI with 4 dimensions of inputs, requiring two dimensions of optimized outputs in order to solve a problem. I have two giant sheets of paper which I am slowly colouring in as to my settings at each possibility.

- Owen

This diagram was intended to demonstrate the Complement of a Fuzzy set (Figure 4.7, pg. 101, Negnevitsky)

As Negnevitsky presents it, a triangular set A, in a domain of 0 to X and the standard memberships of 0 to 1, the complement (as he shows) is the inverted set A on the domain. This is incorrect. The complement requires that  when x has a membership of 1 in A then its membership in NOT A is 0, and when its membership in A is 0 then its membership in A is 1. The complement, then, is everything NOT in the triangle that Negnevitsky has labeled “Not A“

So for anyone looking at that diagram going “huh?” I’m not surprised! In fact, his diagram of the complement completely equates to the diagram of A. Though the triangle is upside down, the percentage of membership would still be the same, though it seems like it should be quite different graphically.

Negnevitsky, M., (2005) Artificial Intelligence – A Guide to Intelligent Systems (Second Edition), Pearson Education Limited, Edinburgh Gate, Harlow

The surprise came on pages 77 and 78, where he presents how an ES (Expert System) would handle conjunctive and disjunctive rules. To determine the certainty factor, he presents that, one takes the minimum of the antecedents (for conjunctive rules) or the maximum of the antecedents (for disjunctive rules) and then multiplies by the certainty factor of the end hypothesis.

I feel this approach is actually flawed.

Flawed? How can I say that it is flawed? Well, let’s take a look at his example:

"IF sky is clear

AND the forecast is sunny

THEN the action is ‘wear sunglasses’ {cf 0.8}"

to "sky is clear" he assigns the certainty value of 0.9, and to "the forecast is sunny" he assigns the certainty value of 0.7.

For his calculation he takes the minimum of {0.9, 0.7} and multiplies by the certainty factor of the hypothesis {0.8} receiving the value of 0.56.

But this misses the point of what an AND is – it is accumulative. Both conditions MUST be true/satisfied for a positive result. If he has a certainty factor of any less than completely certain, then his result will be wrong. 

This is a diagram I did up to illustrate how the AND and OR operators would work on certainty factors.

It seems strange to me how he has first approached the situations of multiple antecedents – if you read on to the next couple of pages you see him deal with situations with multiple rules… he uses the correct approach when dealing with different rules – why doesn’t he use the same method on situations with multiple antecedents but singular rules?

In essence what he is doing is calculating the certainty factor of each situation (rule)… these then become the antecedents for his calculation of the final hypothesis certainty factor.

Anyway, I’m enjoying the book, I recommend you get yourselves a copy.

- Owen

Reference:

Negnevitsky, M., (2005) Artificial Intelligence – A Guide to Intelligent Systems (Second Edition), Pearson Education Limited, Edinburgh Gate, Harlow

 Let’s start by taking a look at the the lookup tables.

At minimum, to catch the full capabilities of this design, these would need to be logically separated. You need to determine the full extent of the possible domain, and divide the space allocated to each portion up appropriately. The power of this particular method comes from the speed increases – by not having to search or manipulate the entire domain, any program need only to look at one particular area of the domain. As an illustration, rather than having a singular array, you now have separate arrays with smaller domains.

So these lookup tables have pointers to the stores of concepts…

This is extremely useful for our system, because it is a series of pointers, the concepts need not be on the same system, you can have the concept stores spread around the world, on separate servers, or localised on separate drives. This is insanely awesome for the system administrators, because they do not need to take the system offline in order to do maintenance, to expand the system, or even move its location.

Let’s say I had a server, in this server, I have 26 drives on to which my concept lookup table is divided. These are mapped on the server, drives A-Z… driver Q is nearly reaching full capacity and I have obtained a remote data store with larger capacity… what do I do? Firstly I copy the drive to the new server. Then I pause access to the original drive and remap the drive to the new remote server. I then synchronise my old drive to my new drive (because whilst we have copied the drive, there may have been data change during the transfer – synchronising the drive would be considerably fast because we are only doing comparisons, and minimal transfers). We then unpause access to the drive, allowing the system to perform any actions that are waiting for access. ‘Voila, transfer complete with minimal delay to users.

What’s more, because we’ve used pointers, the actual concepts don’t even need to be logically ordered. We can dump the concept on any server, where ever there is space. Rather than having to search for the concept, we KNOW where the concept is because of the lookup table.

As I was pondering the concept, it dawned on me that a traditional rule based system would actually be quite silly for large sets of rules. For a small quantity of rules it would be easy to navigate through them to find the ones that apply to a given situation… but what about for larger problems with multiple domains of knowledge required, and many rules flowing on from each other? And what if the problem was not entirely concrete?

There has to be a way of navigating through rules such that it is efficient, can deal with degrees of plausibility, and can span large and diverse domains of knowledge… and to add further complication, what if we were to make it so that it could learn?

I believe it is possible to build such a system, and below I will begin to detail how.

It is seems to be a very big task that needs to be performed – and yet the human mind is quite capable of it! Reflecting on how we think raises an immediate point… we DO NOT look through all our knowledge when we attempt to solve a problem. This would be foolish. Instead, a problem triggers thoughts grounded in the history of the things we have previously looked at and analyzed. To my mind, there are three important factors that influence the thoughts that are brought to mind:

• The items within the problem itself
• The context in which the items are looked at
• The frequency of memories that are linked to the problem

The first is trivial, the item has an appearance and attributes, things that describe it. These help link us to concepts about the idea, and give some relation to other ideas. They are relatively concrete and can be used to judge the identity of a claimant object (one that claims to be the item in question)

The second is somewhat more difficult to pin down, the things that surround the idea, or other things we were thinking at the time, can form a context for a thought. These help trigger our memory, and they also serve as links to other ideas – even if they are seemingly unrelated by anything other than coincedence. Within Intelligent Systems, context can be quite helpful in thinking about what domain of knowledge to apply, but it could also help us move between domains. For an example, let’s say we were looking at a house on a dark night, if it had a pointed roof, it might just blend in with the surrounding connifers – in this case the context has masked the true identity of the object. It has not changed its existence though, and we can still gather some understanding of the situation. In this case the context is night – this adds a level of uncertainty to the situation, and one which an intelligent system would need to accomodate for.

The third is an odd beast – what do I mean by frequency? It is NOT simply the number of hits on a particular element. It is a culmination of multiple different things. In fact, it probably would be more aptly put as a Matrix, but for simplicity’s sake, think of it as a function that returns a singular number. This frequency is affected by the context and by the calling thought, it is affected by the context of the original situation, and the calling situation. It is affected by recent thoughts, and the importance we originally placed on it. Thus it would not be a trivial task to determine the frequency of a given thought. In terms of our intelligent system it would allow us to determine the first situation, to look at it and analyze it, moving from the most likely situation based on the frequency it has been given, to the least likely.

How then do we work with these concepts? What do they achieve?

Well, within our system, we start to develop a problem domain. Rather than working within the Knowledge domain that contains everything the system knows, we move the applicable concepts to the new domain, and begin to map out the relationships that are appropriate.

Take, for example, a medical system. A singular system that is dedicated to pharmaceuticals would not be very good at diagnosing a solution to a problem, unless it is in the realm of pharmaceuticals, but if our system knew about psychology, and other areas of medical expertise then the system would have the materials to make a better diagnosis.

A patient comes into a doctor’s practise with a list of symptoms, the doctor enters these into the system. The System then has a look at the symptoms and looks them up in a Concept Table. This table is subdivided into smaller tables, think of it as a dictionary. I tis divided up into smaller tables so that it can be quickly and effectively searched and manipulated. i.e. if we had a singular table with 800,000 concepts, and we then had to add a new concept, we must place it in the table and move any elements that it fits in front of in order that we sort the table. This, of course, could force us to make some 800,000 operations – which is undesirable. So by dividing the concepts up into some format based on the first few characters of the name, we can make the concept easier to lookup.

(In the diagram I have formulated I have subdivided the table twice based on the alphabet – if you had numbers or other characters then it could be broken up into these as well. This makes the domain of concepts being sorted much smaller. To trivialize the situation (as not all letter would have similar quantities) the sort/search domain would be split up by somewhere in the region 26^2 – leaving us to do some 1.2k operations – the domain can further be subdivided as resources require)

If a symptom does not have a domain then anew  domain is created – but it is a tentative domain. A tentative domain is one where knowledge is accumulated but is yet to be confirmed. If we were to use data mining tools on a third party data source which can not be guaranteed then we would make the domain tentative. We could either get an expert to confirm the system’s knowledge or we could get the system to infer the knowledge by the actions taken by the professional on the other end. Eg. If the doctor chose one method over another we would be able to relate the situation as a new context for the symptom. In this given situation, this action was performed over that one, and this was the outcome. As the doctor discovers new things, so would our system.

The system grabs the domain locations that are referenced by the table and begins to build a picture of the situation. Each domain has a series of attributes, these are things that we know MUST be true for that particular domain to be useful. The context may give rise to some abiguity. In our medical diagnosis example, the system would be able to say, well this illness must have this symptom, this symptom does not exist therefor the illness can not be this. If it has not been confirmed whether that symptom does not exist, the system would then look at the frequency and decide whether it is reasonably suitable to request a test (eg. a blood test) to confirm that the symptom exists.

The system would construct a series of relationships, having looked through the table for all instances of domains, it can now begin to determine what possible combinations could give rise to a certain situation – this is hugely important. It now begins to draw upon the domains that are referenced in the system where the context is such that the domain is applicable. The system looks at a table of known joins, looks at the concept or portion of the current domain that is being pointed to, determines whether that point is applicable to the situation, and then grabs the new domain and links it to the current domain. This means that only the domains that are necessary for the situation need be considered. Conceptually, the system is a huge accumulation of cells which can link to any other location in any other domain. The potential to chain is endless, and so the system would need to determine the highest level of plausibility and continue to work through possibilities until all situations are handled. As it consider the highly plausible situations it can make recommendations. The system could endlessly keep searching for possibility – and if possible, it would be good to keep this going, as the system can begin to infer new links between different domains. This in turn would speed up further interactions and improve the quality of recommendations.

At each point, at each link, there would be a search of the concept lookup table to determine both the location and the frequency of the desired concept.

That is enough for today I think, I’ll attach a copy of the simplified diagram I have drawn to give some visual representation of my thoughts!

- Owen

A Cellular Approach to Intelligent Systems