OK...
In Prologesque syntax, let points be defined as
p(X, Y, Z, ...). for all points (X, Y, Z, ...) in that space. For
concreteness, let's use
p(X,Y,Z).
Now in Prolog, we can use p as a function of X and Y by calling, e.g.
p(17, 54, Z) which will return with Z bound to the result. Thinking in terms
of circuits, I have a black box with three wires coming out; I apply a
voltage to two of them and measure the third. That's the feedforward mode.
Now suppose instead of a mere function, I want to implement an FSA. I have
m(State,Input,Output,NextState). I give it State and Input and it gives me
back Output and NextState. I have to read NextState and call M again, giving
it that value as the State argument. I can't simply call m(S,I,O,S) because
it would only recognize self-loop states.
I understand it up to this part, I think.
If we have a set of numerical vectors X1, X2, X3,...Xn, each vector of
dimensionality k, we can implement an FSA by
interpreting, for instance
X(i,j) = j'th component of i'th vector
m=k/4
X(i,1)...X(i,m) = state
X(i,m+1)...X(i.2m) = input
X(i,2m+1)...X(i,3m) = output
X(i,3m+1)...X(i,4m) = nextState
Then, we can submit a query of the form
m(specific state, specific input, variable output, variable next state)
= m(S,I,$O,$NS)
using $ to precede variables
And this can be resolved via "analogical quadrature", which means that
we look at all
vectors Xi whose first 2m components are similar to (S,I), and average
the final 2m
components of all these vectors to get a guess for ($O, $NS). [Of
course, there are many
ways to do this weighted-averaging.]
Is this what you're suggesting?
This seems sensible enough...
The key paradigm shift is to the circuit. Now each of the inputs is a
time-varying signal and so are the outputs. But now I *can* simply connect
the output state signal to the input, because there's an implicit delay along
the wire (or in the predicate). And now, bingo, it's a self-running machine.
I'm not sure I follow your "paradigm shift".
If the input varies, then for input[t] one can do analogical quadrature
and get output[t+S] and nextState[t+S],
assuming the quadrature process takes S time units. Then one can set
state[t+S+R] = nextState[t+S]
Is that what you mean?
What I don't really get is why you think this "analogical quadrature"
operator is so powerful that it
can serve as the core of a cognitive engine....
I see why it could be a useful component, but I don't see it as having
such generic and dramatic
power (within computationally feasible limits I mean).
On the surface, your approach seems a fair bit like Hecht-Nielsen's
"confabulation theory"
http://www.scholarpedia.org/article/Confabulation_Theory
except that you replace his winner-take-all "confabulation" operation
with your weighted-averaging
"analogical quadrature" operation.
I have a serious doubt that any single, simple principle like this is
going to bring you very far toward
AGI...
-- Ben
This essentially stepping backward over the gap between cybernetics and
algorithmic AI. You specify a circuit; every object is active all the time.
Now general, timing dependent circuit design is a God Damned Pain and nobody
would do it if they could get the result by instruction sequences (which are
dead simple by comparison). But there's a new field of "reactive programming"
that imports just enough control from programming languages to the "always
active" paradigm that it looks tractable. And it cuts the size of programs in
half.
Josh
On Wednesday 14 March 2007 18:07, Ben Goertzel wrote:
In my thinking I've dropped the neural inspiration and everything is in
terms of pure math. Each module (probably better drop that term, it's
ambiguous and confusing: let's use IAM, interpolating associative memory,
instead), each IAM is simply a relation, a set of points in N-space, with
an implied surface or manifold stretched between them. If you wire it
feedforward, it's a function; if you wire it recurrently, it's an FSA or
even a Hopfield net-like continuous-state automaton.
I don't yet understand how you get from
a) a set of points in N-space, to
b) a feedforward or recurrent function
(I can think of many ways to do so, but I don't know which you are using.)
Could you be more explicit? Mathematics is fine...
thx
ben
-----
This list is sponsored by AGIRI: http://www.agiri.org/email
To unsubscribe or change your options, please go to:
http://v2.listbox.com/member/?list_id=303
-----
This list is sponsored by AGIRI: http://www.agiri.org/email
To unsubscribe or change your options, please go to:
http://v2.listbox.com/member/?list_id=303
-----
This list is sponsored by AGIRI: http://www.agiri.org/email
To unsubscribe or change your options, please go to:
http://v2.listbox.com/member/?list_id=303
