Re: What is missing from AI ?
- From: curt@xxxxxxxx (Curt Welch)
- Date: 07 Oct 2005 06:13:51 GMT
"JGCASEY" <jgkjcasey@xxxxxxxxxxxx> wrote:
> Curt Welch wrote:
> > "JGCASEY" <jgkjcasey@xxxxxxxxxxxx> wrote:
> ...
>
> >> But it doesn't produce all behaviors equally. It has
> >> its own internal emergent behaviors which make some
> >> i/o actions impossible and some almost a guarantee.
>
> > I'm not sure what you getting at there. An I/O
> > action to me, is the route a pulse might take from
> > some input to some output. All cross connects are
> > possible.
>
> That is not what I found. If I want, say a sequence
> of 20 pulses per unit of time, to go out the last
> far right node all the pulse rates lower than 20
> cycles will take the same path.
One node will force all pulses < 20 to the same place.
But with two nodes, you can filter out pulses from 19 to 20 if you want and
send them whereever you want.
> They cannot cross,
Well, I've talked to you about this many times now.
The 2D flat net topology will not work for 2 main reasons. 1), you can't
cross signals, and 2), signal "reach" is linear instead of exponential.
I've not explored all the options of how to create a complex toplogy. But
I know a few simple answers that get past your problem here.
Wire two nodes together like this to create a 2-in, and 2-out sub unit:
| |
O O
|\/|
|/\|
| |
Where the X in the middle cross over each other but do not connect. The
paths merge at the bottom.
Then build a net like this (it really sucks trying to draw pictures with
ASCII!):
\/\/\/\
/\/\/\/
\/\/\/\
/\/\/\/
Where each X in this mesh is the 2-in 2-out box from above. Wrape it
around into a tube if like as well.
Now you have a toploty that can easily cross signals and route any hidden
layer signal, to some unique output and your issue about "signals can't
corss they can only merge" is gone from the argument.
> *they can only merge*. Also a pulse that enters any
> particular node cannot get to any output group
> larger than number of layers below it.
That's problem 2) from above. But it's not a killer. All it means is that
you need enough layers to calculate all the values you need, then if you
have 100 outputs, you need 100 more layers after that to be able to route
any signal to any output.
But, with a better toplogy, you can do the same with far less than N more
layers for N outputs. You can do it with more like log2(N) layers.
I can draw some examples for you with a pen, but not with ASCII.
Bascaill, you want to to form a tree without cross connects, so instead of
a fan out that starts with 1, goes to 2, then 3, then 4 nodes on each
level, you want a topology that creates 1, 2, 4, 8, 16 effect. So a single
created on one level, can be routed to any one of 16 different nodes, after
only 4 layers.
> My point earlier was not that you had not responded
> to the email rather that you don't actually test your
> nets and respond to my suggestion that they simply
> can't do what you claim.
Yeah, we know I have that problem. :)
The problem is that I use posting to Usenet as a way to procrastinate. And
I can justify a quick post here or there (which all too often runs into
hours of posting). But some of tests you suggest are real projects. And I
can't do a "real" project because my life is full of 10 other real projects
I'm not getting done which are all far more important than AI. So while I
can come here and BS, I just don't have time to do real AI projects in my
life right now.
Also, some of your claims like the ones above are baseless. I don't need
to test the net to know that those issues are not a problem. Those issues
only make it clear that the simple flat toplogy is a dead end but I've know
that for years now. The real project I need to do, but don't really have
the time for, is to create and experiment with multiple more complex
toplogies, like the X net design from above, but also ones that create the
exponential fan-out effect.
Your morse code test is a good one. It's on the todo list. But I just
don't have the time to justify for that project. I really should just
attempt to get away from my Usenet posting addiction and deal with the
things I've been ignoring in my life, but that's another issue... :)
The number one thing that has been on my list for this work is figuring out
the correct way to do secondary reinforcement/reward prediction. So, one
more reason I haven't gotten to many of your suggestions, is that none of
them are as important to me as the reward prediction probelm.
If I work on your morse code test, I might find that I can't figure out a
way to even hand-code a solution using these types of nodes, in a
feedforward net.
However, I'm almost 100% postive that I can hand-code any function in a
recurrent net with these nodes. And my plan to get from here to human AI
requires I use this basic learning net in a recurrent system. I've got a
lot of ideas about just how to build that. But it's wrong to work on that,
until I get reinforcement learning working correctly in the feedforward
toplogy first. And to get RL working like I want, I have to figure out how
to do reward prediction.
So, what I belive here, is that if you give me a problem I can't solve in
the feedforwad net, it just means it's a problem I will have to wait until
I'm working on the recurent version to solve. And that's going to have to
wait until I finsh RL on the simple net.
So, even though I would like to be able to show you things to make you have
more faith in this network, when I don't have the time to do the things I
need to do, it's hard for me to justify taking the time I do have, and
working on projects that I don't expect to show me anything I didn't
already now.
Also, I took the time to show you have these nodes can create a half adder
function when you thought they couldn't do that. But when I showed you
they could, it really hasn't helped much in changing your overall view
about what these nets can do on "hard" problems. So, I also get the
impresion that if I showed you how to hard-code a morse code decodor, you
would just move the line once again, to something harder and still not have
faith.
What's clearly important anyway in my entire approach is ability for a net
to be trained with RL to do something complex. That's the real magic
missing here. And even if the net has limits that prevented it from
solving some class of problems, if I can get the net to auto-train for
something people though a net couldn't be auto-trained to do (like allowing
a robot to learn to walk on it's own with only RL), or in solving some
class of pattern recgnition problems. Then that would be be more
important, then proving there was something it couldn't do.
So even though I would like to work on all your suggestions, my life really
isn't letting me do it right now.
> The pulses act like streams of water coming down
> a mountain or hill slope. They merge not diverge.
Right, switch to the X net toplogy from above then the mountain hill
anology no longer fits very well because the streams can cross without
merging at every X.
> They change the landscape as they go but not with
> anything meaningful. You can change the landscape
> by adjusting ratios but every change messes up
> the other settings. And the higher the layer in
> which the change is made the more likely any change
> will make a mess of all the other settings.
Yes, these nests are VERY hard to program by hand. That's why they were
not designed to be programmed by hand. They were designed to be solved by
a statistical processes which is similar to the problem of inverting a
matrix. It's just not something you can do by hand very easily.
This is why I think it's so important to get the learning working and not
as important to spend a lot of time trying to hand-code thigns that won't
in the end look anything like what RL would create anyhow.
> Your net has the property of a decision tree with
> all the brittleness that comes with such a design.
> And any RL based on adjusting the ratios faces a
> combinational explosion.
Right, it's very brittle because everything is dependent on everthing else.
You can't change one thing without breaking 3 others. And when you try to
fix those 3 others, 9 other things break. This is what makes it hard as
hell to program by hand because to make a change, you have to change
everything at once. It's the same problem as trying to solve a large
system of equations. You can't just change one number without it effecting
3 others at the same time. It's like trying to solve the rubix cube.
But, these type of systems can sometimes be solved with iteration which
slowly pushes it towards a stable solution. And that's exactly what RL is.
It's an ittertive improvement technique that is constantly changing
everything at once, but it's changing the variables with the most error,
the quickest.
The question of course, is if a given design will stablize and converge on
an answer, or will it just oscillate wildly and never find an answer?
This is the big and exciting question to me. Will this type of network
correctly converge on solutions. Will it correctly converge on even simple
problems? I'm excited about this design because I think it will (and I've
been looking at RL network designes that do not converge on even simple
answers for 25 years now). It has shown to be very stable in all the
simple tests I've done. But now I have to figure out how to add secondary
reinforcement effects without breaking that stability. And many thoughts
about how I have to do it creates a feedback loop in the training that I
know will make it unstable. So I'm focused on finding the answer to the
correct implementationm of the reward prediction problem because I think
the net will be able to learn some very exciting things on it's own when I
get that right.
The fact that the net might have some real limitations on the class of
probnlems is not as intersting to me as the idea that it might have some
very exciting powers, for the class of problems it can solve.
> If a pulse shoots out to the right it eventually
> has to hit a left stream and thus is merged and
> then goes to the left again. That may not be the
> action required.
Right, that's just a fall out of using the wrong network toplogy. I've
explained this to you maybe 10 times now but yet you keep bring up the
limitaions of the flat toplogy.
The reason I'm not quick to "fix" the toplogy, is that even the flat
toplogy is fine for finishing my development of the RL algorithm.
For example, I need to be able to send a flat net two changing signals, and
have the network create a few outputs based on the combined state of those
two signals. Like one output when both signals are high frequency, one
output when both signals are low, another for H/L and another for L/H. The
flat net can probably do that if I just don't give it a problem that
requires it to corss the siganls to get them to the right place. So I can
develop the RL algorithm on simple little tasks like that even with the
flat net.
> I have watched the net in action. All the little
> pulses look like skiers bouncing down left sloping
> mountain sides. Sometimes skipping to the left over
> to another edge, mostly eating away at the slope as
> each layer of counter values is reset.
Yeah, I've spent hours staring at it as well. But that's just with the
flat net. I've not spent hours with any other toplogy yet. I don't even
know if I could understand what I was looking at with a more complex
toplogy - I expect it to look almost like random dots flashing on the
screen.
> > In a large enough net, the outputs will look random.
>
> Mine don't look random.
Yeah, I know what you are talking about. For example we see sweeping
actions that look a look like water running down a pain of glass sweeping
back and forth. So if you look at just the nodes on the output layer, you
see the nodes activating in a sequence at times and that's not random at
all even if it does jump somewhat randomly at other times.
But, that was with a single highly structured input feeding the net with a
bad topology. I believe you would see a very different effect with
something as ismple as the X net design above. Feel free to code it for me
ane let me see what it does! :)
However, I suspect most of those patterns form because of the toplogy of
the flat net causing the two outputs from a node being merged back together
only one layer later. That's just a bad topplogy for this net. The split
signals should not be merged back together until they have first been
merged and split with all the other signals. In effect, what happens in
this net is that two separte signals are compared with each other for
correlations by merging them together and then seperating them. There's
not a lot to be gained for merging two signals back again so soon because
you have already compared them for correlations and you don't want to do it
again, until you have tested for correlations with all the other data.
But more important, have you tried feeding the same net with 3 inputs which
aren't so highly structured? Or just one input that in fact has a lot of
content like an audio stream of Music? I've not tried anything as complex
as music, but I've treed feeding nets multiple streams and it turns very
random very quickly (i.e., too complex to see any real patterns in the data
with the eye).
The piont is that the default behavior of the node is to converge onto the
gap value which causes an even 50/50 split which means it's trying to
create a mapping from one signal (symbol stream with one symbol), to two
signals (symbol stream with two symbols), where the symbol probibility in
the resulting data flow has equal probability and should be carrying maxium
information.
> The pulses merge as a result
> of the way the net works. And like many streams pouring
> down the mountains and hillsides, they may change their
> courses over time, but they tend to come together and
> become one. The actual outlet into the sea may drift
> along the coastline a little bit before it settles
> but any new streams will break that up.
Yeah, the flat net looks just like that at times. It's neat, but as you
say, not very random at all.
> > If you feed very structured (simple) data to the input,
> > and use only a small net, you will see structured
> > behavior. But no matter how structured the data is,
> > if you make the net large enough, the output is very
> > random and equally distributed.
>
> My nets are 64 x 64 how large do you want them? The
> output is not random even with random inputs and
> random settings of ratios.
It's should be most random with 50/50 ratios. The more you move away from
that, the less random it gets because you are creating a final symbol
stream which has uneven probabilities for each symbol.
I'd have to see your code to see exactly what you are doing but maybe what
I wrote above makes my point clearer. And maybe you have seen behaviors in
these types of nets that I've not even seen. :)
A 64x64 net is plenty big enough.
> > Some of this actually requires improved topologies
> > over that the type network we have played with).
>
> Like a complete make over :)
The topology does need a complete make over.
The topology is really not all that important to the very nature of what
this net is all about however. The point is that of the RL works right, it
shouldn't care what the topology is. It will cause the net to converege on
a solution if there's a solution to be found with that topology. So a bad
topology should only limit the class of problems a the net can solve. A
good topology should allow a wider range of porblems to be solved with
fewer nodes, and allow it to converge on the answer faster. At least
that's what I expect and hope will turn out to be ture.
> > The reward prediction system will develop an
> > estimate of the value of the current environment.
>
> A potato peeling system *will* peel a potato.
> That doesn't explain *how* it is done, and in
> particular with your nodes.
>
> You always say it *will* do this, that or the
> other without an actual demo.
Right. You just gota have faith my man! :) (Just type in the numbers and
hit execute and don't ask questions! (Lost)).
What I like most about the net is that it seems to have the right
characteristics to converge on answers to RL problems. And so far, all the
stuff you and I have played with together, included no RL. I added it to
your own net and sent you the code but I don't know if you tried looking at
that. So I think you have not yet seen the stuff that will really give you
faith that there is something interesting goin on here.
> My logic gates will learn to add two numbers together.
> Ok. Show me. Then add another input and train it to
> multiply two numbers when that new input is active
> and still add two numbers when it isn't active although
> both behaviors are sharing logic gates.
Yeah, that's what I want to see. Feed it two binary numbers with a few
digits and see if we can train it to be an adder that developes the correct
logic for carry! That's the stuff I suspect this net could learn once RL
is working correctly.
> With your system you might represent the numbers by
> pulses per unit of time?
Well, for the binary adder problem, the most natural I belive would be an
FM encoded digit. So you have one input for each digit, and it's got a low
fixed frequency to repesent the value 0, and a high fixed frequency to
represent the value 1. So, for exmaple, feed it 4 inputs, which represent
2 binary numbners of 2 bits each and train it to produce 3 outputs which is
the 3 bit sum of those two inputs. THen try more digits and more digits
and see if it can learn to build the adder, and if it can, see how large a
net it needs for each larger problem and see how long it takes to converge
on the answer.
The training would be supervised training-like because we know exactly what
output we want it to produce so you just reward and punish every pulse.
THat makes it much easier to learn than other types of RL problems where it
has to find the right output on it's own. But it's still hard because the
net has to train all the middle terms correctly on it's own.
This problem will require multiple signal lines to cross, so the flat net
is right out. You need a topology with plenty of room for signals to cross
without merging first. And the exponential fan out will no doubt help it
find the right answers in a much smaller net.
But this is exactly the type of problem that's good for studying because if
you can make it work in one net, you can then test lots of different
toplogy ideas and see exactly which topologies work better for this type of
problem.
Are there any NN's that can be trained to create a binary adder?
> You have built your flying machine, don't leave
> it in the shed, push it off a cliff and see what
> happens. And then analyze the result. Don't keep
> saying it is going to fly one day.
But, but, what if it crashes! I'll loose my dream!!!
> > For example, if the system gets a reward when
> > the arm is raised, the optimal behavior would
> > be to produce 100 up pulses in a row to get the
> > reward as fast as possible. You will have to
> > wait a million years for that to happen, so the
> > odds of the system finding the optimal behavior
> > without help, is zero.
>
> > But the odds of the arm getting into the up
> > position at some point in the near future, is
> > much more likely, then the system producing the
> > optimal behavior. And if the arm gets to the
> > up position, and the bot is rewarded,
>
> Why is it rewarded?
My theory is that the net will find more features in common to the reward
state when the arm is nearer to the correct position. And if there are
more features in common, the prediction of a reward should go up and that
should create a reinforcement.
Think about my net this way. At any point in time, every node is in one of
two states. It's either in the state that it will sort the next pulse out
the high side, or it's in the state that it will sort the next pulse out
the low side. So, at any point in time, a 64x64 net creates a state space
of size 2^4096. A network with 50/50 weights, should have an equal
probability of being in each state.
This 2^4096 state space is the nets representation of the current state of
the environment. And it's this same state space, which is used to predict
the current expected reward from the environment. Now, in theory, as the
environment gets closer to a state configuration that matches the states
where it has seen a lot of rewards, the higher the expected reward the net
is predicting.
Anything the net does to change the environment into a state which is seen
as "better" by this prediction system, will be rewarded. So in theory, as
the arm gets closer to the position where it was rewarded, more of these
4096 bits will match the "good" configuration.
And, on your question about "no big deal about temporal", let me point
something out here. All these nodes change to the H state when a pulse
goes through them, but the snap back to the L state, when their timer runs
out. So the entire net, is changing it's state dynamically based on when
these timmers run down, and those changes represent the nets idea of the
current state of the environment. So it's a very complex temporal state
prediction device for predicting what state the net things the environment
is in, at any point in time. It's not waiting for the next sensory signal
to show up to find out what state the environment is in, it has it's own
temporal prediction of what is happening in the environemnt at all times.
This type of behavior is logically very different than a network which is
doing nothing but processing data which is fed to it even tough it is in
software only a network which is being feed data - but the fact that it's
being fed, and is constantly using, a real time clock value, is what makes
it somewhat different than most non temporal nets.
> > ... then the
> > reward prediction system has the chance of
> > association the position of the arm, with the
> > reward. Now in the future, the reward
> > prediction system will, in theory, tend to
> > predict a high chance of a reward, as the arm
> > gets closer to the up position. This works
> > because more features of the environment match
> > the feature set of when the arm was up. So now,
> > every little movement in the up direction is
> > making more features match the "good" state,
> > which rewards each of those up actions and
> > punishes each of the down actions, without
> > having to wait for the optimal behavior
> > to happen on it's own.
> >
> >
> > So, the prediction system is pushing the behavior
> > set towards the optimal behavior of a sequence of
> > 100 up commands without having to wait for that
> > sequence to show up on it's own in 100 billion
> > years. The more the up behavior is reinforced,
> > the closer it gets to the optimal behavior, and
> > the sooner it will find the optimal behavior.
> > So it will be performing the optimal behavior
> > most the time.
>
> It is easy enough to simulate say a simple
> arm limited to a 2D plane. Now lets say the
> input is the position of an "apple" and the
> position of the arm's shoulder and elbow
> joints. When the "hand" end is in the same
> position as the "apple" it gets a reward
> and then the apple changes position.
>
> I have already programmed the simulated arm
> so all I need now is the explanation of how
> to get it to learn to make its "hand" contact
> the "apple".
>
> Lets make it really easy. Define points in
> terms of the two joint angles so the "apple"
> input position is the two numbers you need
> to have as feedback from the joint angles
> for a reward.
>
> arm angles -->| |---> pulse up/down shoulder
> apple angles -->| |
> reward signal ->| |---> pulse up/down elbow
>
> If arm angles = apple angles Then reward = True
>
> Can you explain to me how the reward prediction
> system will allow the "robot" to learn to get
> its apple reward so I can program a demo?
I can explain the theory I believe that needs to be behind it.
You have simplifed the problem above to one where the net has the power to
adjust a variable indirectly with up down behaviors and all you are asking
it to do is adjust that varibale until it matches the apple value - though
above you are asking it to do two of those problems in parallel. Let go
ahead and simplify it down to one problem - so the arm angle is a single
arm position input and the apple angle is a simple input and it's got
outputs that control the arm angle indirectly in some complex way.
What has to happen, is that the net needs to mix and max the two input
signals in many different complex ways as the data flows through the net
(which is clear that it will do this as the network splits and recombines
the signals in lots of different ways as the sensory data flows through the
network). But some combination of those complex functions need to
correctly correlate to the behavior the network needs to create.
So, for this problem, we need to send pulses out the down output, when the
hand is above the apple, and send pulses out the up output, when the hand
is below the apple.
Now, think about what is happening in the net. If you were to let the
network run, with it's default 50/50 split, but no RL at all, you can move
the apple up and down and let it move it's arm up and down in response to
whatever pulses came out of the net. The arm motion is going to very
chaotic and unpredictable. It's going to basically be a drunken sailor
walk.
But, if you were to take this net, (after the gap values converged), and
monitor the behavior of the output of each node, you could count how many
pulses came out of the node, when the arm was above the apple, and how many
came out of the node, when the arm was below the apple. What you would
most likely find, is that nearly every signal in the net was nearly equal
(close to the same number of pulses for the two conditions), but that
almost every one of them would have a bias - that is, signal X in the net,
would tend to produce more pulses, when the arm was above the apple, than
when it's below the apple over the long term. And signal Y might be just
the opposit, it would just happen, based on the function it created because
of where it was located in the network, a signal which which tended to
produce more pulses when the arm was below the apple.
Now, if we could get all the signals which produce more pulses when the arm
is high, and route those to the "down" behavior, and route all the other
signals to the "up" behavior, we would have a network which tended on
average, to move the arm up, when it needed to be moved up, and down when
it needed to be moved down, and the net would have solved the problem.
Now, the way RL makes this happen, is that the intial rewards, must be easy
enough to get, just by chance. And in this case, I think they are. The
arm will just by dump luck, move to the correct position at times.
Now, RL could probably work on this problem, just by rewarding that last
pulse that happened before the reward. So, a pulse goes through the net,
the arm takes one step up, and the system rewards that pulse. It does that
by adjusting the programing of the small set of nodes used to get that
pulse, to the correct (up) output. This will encourge those pulses, to
take that same path, more times in the future.
Now, however, as you keep running this, lots of pulses, taking different
paths, will end up being rewareded. The ones that manage to do the right
thing the most often, will be the ones that get the most rewards, and the
net will reshape itself, to make sure the signal which does the most good,
is the one most likely to be sent to the "up" output, and if need be, it
will push the other data out of the way (force it to take other paths).
So, even without reward prediction, it's quite possible that this network
could learn on it's own, though a long and slow training process, to shape
the net in a way that will allow the net to solve the probnlem. It
basically means that the net must be able to form a circuit which is able
to do a compare on the two input values, and produce a "high" vs "low"
output signal.
But even if the net can't do a "perfect" job at creating those high low
comparison signals, if it can at least produce a signal that is more active
for high and less active for low, that will be good enough to allow the net
to learn to move the arm to the solution and get the reward.
Now, the issue of the reward prediction system is that the internal state
of the nodes of the net, is also liekly to correlate to a "nearness"
function. Every time the net is rewarded, it's current state, is marked as
a "reward" state. Over time, the nodes will develop a correlation with the
rewards. One node for example might be in the high state, 80% of the time
when there's a reward, and in the low state 20% of the time when there is a
reward. So, every time the node is in the high state, we predict an 80%
probablity of a reward. When it's in the low state, we predict a 20%
probability of a reward happing in this state.
Other nodes might end up with an equal probablity of reward between states.
Then end up telling us nothing useful about the odds of a reward happening
in this state. So, some nodes will statistially be shown to be more useful
as reward predictors than others.
So, at any time, you can poll the entire state of the net, and calculate
the probablity that a reward is about to happen. And, when a node goes
though the net, and changes the state of the nodes it touches, it's
changing the net's estimate of the probability of a reward.
Now, if the action of a pulse ends up changing the net to a state where
it's predicting a higher probability of reward, that pulse can be rewarded
for doing that without waiting for the next real reward.
And if the pulse changes the state of the net, to a state that lowers the
estimate of a reward, that pulse can be punished now, without waiting for
the next real reward.
So, the point of this net, is that it "understands" the real time state of
the environment, not by a simple vector of intput values, but by the
complex temporal state of every node in the network. And it can then, with
simple statistics, correlate the real external rewards, to the the state,
so that each node becomes an independent reward predictor. And when they
all vote together, you get a result which reflects the networks current
best estimate of a reward showing up while in this state. And, if this
reward predictor is worth anything, it's likely that the reward prediction
will go up as the network gets closer to a state where lots of rewards have
been received, and the prediction will go down, as the network gets further
away from the better reward states.
So, with the help of the reward predictions, the network can train itself,
without having to wait for the real external rewards.
So, this type of net is meant to be used with a complex environment, where
the state of the environent, is way too large, to use traditional RL
techniques, where the computer would have to keep some unique variables for
every possible state of the environment. But, a small 64x64 net, has the
ability to create it's own understanding of the state of the environment,
as a 4096 bit number. And the net will map the entire real time state of
the environment (as it understands it through the sensory data), into this
2^4096 state space.
And the purpose of this net, is to know how to best react, to any possible
sensory input, at any point in time, based on the current real time state
of the environment.
Though RL, the net will then adjust it's mapping from sensory data, to
behavior, and in doing so, will change how this 2^4096 state space, is
actually assocated with the far larger, state of the real environemnt.
And the point of doing the reward prediction, is that the net trains orders
of magnatude faster. Instead of getting a reward once every 100,000
pulses, the net can train itself on every pulse. And instead of trying to
go back and apply one reward, to the last 100,000 pulses (because we don't
know which of all those might have helped us get this reward), the reward
prediction system does it for us without stoping to perform some complex
time intensive credit assignment task. We can train the pulses as they
happen.
So that's the theory about how reward prediction works. Does that help?
Or is it still too abstract?
As I said however, the actually implemention I'm still thinking about.
However, forcing me to write all this did help. Thanks. :)
--
Curt Welch http://CurtWelch.Com/
curt@xxxxxxxx http://NewsReader.Com/
.
- Follow-Ups:
- Re: What is missing from AI ?
- From: JGCASEY
- Re: What is missing from AI ?
- References:
- What is missing from AI ?
- From: JGCASEY
- Re: What is missing from AI ?
- From: Curt Welch
- Re: What is missing from AI ?
- From: JGCASEY
- What is missing from AI ?
- Prev by Date: Re: What is missing from AI ?
- Next by Date: Re: What is missing from AI ?
- Previous by thread: Re: What is missing from AI ?
- Next by thread: Re: What is missing from AI ?
- Index(es):
Relevant Pages
|
