AI -- a realistic project
Less talk. More action.
I've had an interest and have been "doing AI" for about 10 years. I've
got lots of opinions on the subject, surprisingly none of which have
been represented here in recent discussions. However, I'm a bit too
tired this morning to go on a proper rant, so that will have to wait.
I propose that instead of sitting around trying to decide what do we
need, what is best, why are we doing this, etc. we just jump in and try
to accomplish *something*. How about we build our simulated world that
has some agreed-upon (if we can mangage that) physical laws &
properties, and then various people can go off and build an "entity"
(using any method of their choosing) that will live in this environment,
at least until the rules of the world determine that it has been killed.
It should be very simple (in concept) which will allow us to get moving
on this. This does not imply that complex behavior cannot emerge or at
least it allows for the possibility for something interesting happening
that will take us down further roads. So instead of trying to build
Einstein's brain, we can just focus on a basic property: adaptability in
the face of the (partially) unknown.
There would be three phases to such a project:
Phase #1:
First, we collaboratively design an environment -- a world. This should
be very simple! We are really only designing the "rules" of the world
-- we will plop our entity into many such worlds -- all with the same
rules, but with different configurations (so it would have to know or
figure out the rules and be able to adapt to any configuration, and not
just memorize one environment.) I have in mind something like a
two-dimensional grid world that is guaranteed to be a minimum of X by X
blocks and a maximum of Y by Y blocks (X & Y to be decided.) In
addition, there will be several (not too many) different types of
objects that can exist in the world -- food, obstacles, other
(mechanical) entities, etc. The entity will be limited to certain
simple actions like move, push object, consume object (eat a rock and
die!), etc. The world will be updated in discrete time-steps, and we
make up rules such as:
-- an entity will die if it does not eat X often
-- each piece of food is worth X units of energy
-- food will grow and multiply in certain areas sometimes, other times
it may start to dry up in one spot and spring up elsewhere (or there
could be food *and* water, both needed)
-- are there (mechanistic to make it simple) predators or competitors
for food?
-- etc.
-- Point is the environment is not static, but not erratic or random
either.
-- You will be tempted to come up with lots of subtle rules (night &
day, etc.) -- save those for next time! Baby steps...
We equip our entity with certain sensors that allow it a (limited) view
of its environment (it can't sense the whole world at once -- it must
direct its attention and move about to discover things).
Then all those rules are coded into an engine that implements the world.
Who or how it is coded is not particularly important -- just so it
correctly implements the agreed-upon rules, can show us what is
happening, etc. On each time-step, the engine will provide the entity
with the current state of its sensors, and will accept an action (or
non-action) as input from the entity. Of course, it will also update
any other goings-on within the world. Optionally, each time-step could
be a *literal* amount of time on a benchmark machine -- if the entity
doesn't provide an action within a certain time-frame, time in the world
goes marching on anyway (memshare library, anyone?).
That's phase #1 -- it is basically a game of adaptability, but one for
which any of us won't know the best strategies beforehand (probably).
It is also a game that has no guaranteed starting configuration -- the
entity will simply be plopped into an existing world without knowing its
exact size, or where the food is, or the best way around the obstacles
and away from the predators.
Phase #2 -- Individuals or groups of individuals each take a copy of the
engine (or make your own so long as it adheres to the standards --
however, there should be an "official" version) and go off and create an
entity to live in such worlds. Each person or group can take any
approach they want using any resources -- you want to hand-code for
every contingency? Go ahead -- it will be a good benchmark. You want
to use a ton of memory and try to create a complete internal map &
record of what's happened in the world? Go ahead if you think it will
work. Like neural networks? Use them. Don't want to hard-code
anything and instead concentrate on coming up with a system for
learning? Excellent. This is not a competition, only an exhibition.
Phase #3 -- Public tests of the various entities using random or
specifically designed but previously unknown configurations of the
world. We note which approaches worked best, which ones worked most
often, or for the longest time, etc. Maybe replace previously
mechanical competitors for food with some one else's entity so we have
two or more intelligences running around the same environment. See who
dies. Basically we moodle over our results and let it naturally lead to
new places. If we ever get that far, that is.
In short, I believe the process itself will be far more fascinating than
sitting around jabbering about it. If this all sounds too basic and
boring, then I'm sure you can come up with something great in no time
and we can move on to making dolphins. Just describing this relatively
simple project should make it apparent that it really isn't so simple
after all and trying to start right away with a consciousness is a bit
unrealistic, to say the least....
|
Not Categorized, Please Help
|
|
