I've been to think lately that the solution to creating a realistic AGI
design is psuedo design. What do I mean? Not simulation... not practical
applications... not extremely detailed implementations. The design would
start at a high level and go deeper into detail as possible.

So, why would this be a solution? Well, before I mention the cons to this
approach, consider the following:

*Problems it would solve:*
1) There is no money and little interest for AGI. Even if you could get
money, I am 99.99% sure it would be spent wrong. I know, I know... I'm
supposed to be trying to get us money, not dissuade it. But, I really think
we are repeating the mistakes of earlier researchers that promised too much
on unjustified ideas. Then when they failed, it created AI winters, over and
over and over again. History repeats itself.

So, getting us more money would likely do harm in addition to too little
good, the way it would be spent, for me to care. Extremely few people are
interested in AGI and among those that are, their ideas about it are very,
very flawed. We tend to approach the problem using our typical heuristics
and problem solving techniques, but the problem is no longer amenable to
these techniques. For example, the idea that patterns finding is sufficient
for intelligence. It has not been proven beyond my reasonable arguments
against it. Yet, people are getting funding and pursuing entire
architectures based on it. Does that really make sense? Nope. We must pseudo
test and pseudo design our algorithms first. Why? Because after spending
several years on these designs that I can reasonably predict will fail with
a high likelihood, we'll be back as the same place we were. Wouldn't we be
much better off figuring that out earlier rather than later through fast
prototyping techniques, such as the one I mentioned (pseudo design and
testing)?


2) Implementations tend to get overwhelmed by the desire to show immediate
results or achieve practical short-term goals. This completely throws off
AGI implementations, because these other constraints are not compatible with
more important AGI constraints.


3) We could find a solution much faster... AGI is a massively constrained
CSP (Constraint Satisfaction Problem). The eternity puzzle is a great
example of such a problem. If you approach the eternity puzzle using
heuristics alone to generate a likely solution, such as how pretty the
pattern is, or how plausible it is that the designers created this design,
it is guaranteed to fail. This is especially true if it takes you even a few
minutes to reject the design. The puzzle has so many possibilities that if
you were to try to look at each one to see if it was a solution, it would
literally take an eternity.

So, how do you solve such problems? You start with the most constrained
parts of the puzzle first, and you use heuristics to guide your search for
solutions paths that are likely to contain a solution and avoid solutions
paths that are less likely to contain a solution. Most importantly, you have
to try a lot of solutions and reject the bad ones quickly, so that you can
get to the right one. How does this apply to AGI? It's almost exactly the
same. Current researchers are spending a lot of time on solutions that were
generated using bad heuristics (unjustifiable human reasoning heuristics).
Then they take forever to test them out (years) before they inevitably fail.
A better way is to test solutions with as minimal effort and time as
possible, such as by using pseudo design and testing techniques. This way
you can settle onto the right solution path much, much faster and not waste
time on a solution that clearly wouldn't work if you simply spent a bit more
time analyzing it. Yes, such an approach has problems also, such as
dishonesty or delusion in how the algorithms would actually work. I'll
mention these more below. But, we have those delusions and problems already
:) So, overall, this approach seems to be significantly better.


4) if we could show that a pseudo AGI design works in sufficient detail and
with sufficient plausibility, it would likely change the minds of:
-many people that don't think AGI is possible,
-those that think it isn't possible in their lifetimes, and
-those that think it isn't worth investing in.
In other words... we would get the money, help and interest needed to make
it happen. Demos are great at generating interest in things that are very
complicated. This would be a fantastic demonstration.


*Pros:*
1) Fast design testing and rejection
2) Rough to fine design... would arrive at a solution faster because it uses
the "*Most*-*Constrained*-Variable-First" heuristic (such as has been used
to solve the eternity puzzle... you solve the most constrained portion first
to avoid having to try out many possibilities that will fail at the most
constrained part).
3) Less pressure for practical applications and more focus on important AGI
issues... this removes extra constraints that are not compatible with AGI
constraints.
4) More man power because the design is less costly, less time consuming and
requires less detail-oriented expertise.
5) Can you think of other pros?

*Cons:*
1) People will make assumptions that are false and will delude themselves
about these assumptions even if you point out flaws.

I don't think there is anything we can do about this except for people that
have not accepted the mistake to create different designs in parallel. If
you disagree with someone, then you'll have to create another branch of the
design or start a new design. At such a point, new comers will have to
decide who is right and who is wrong and choose the project they believe in
the most.

2) Important and honest assumptions may be wrong.

I claim that this is ok because those assumptions would have been made
anyway. At least many of these assumptions can be thrown out at the
hypothetical stage before spending tons of time and money on a bad design.
In addition, I think the work on the rest of the design will likely still be
of value and will allow an implementation project to fix the assumption
mistake and move on.

3) Often real world testing provides us with unexpected, new insights.

While this is true, I don't think it's worth the down side of current
approaches... which is that they take forever to fail and stay stuck on
flawed designs, while trying to convince others that they are right.


*Realistic Testing*
I would also suggest to pretend that the pseudo design is a real design
whenever it makes sense to do so. So, how do we decide when to go into
detail and when not to? It depends on the value of that detail. If we can
make reasonable assumptions and then keep moving forward with the design, we
should. If we can't, then we need to go into more detail. Sometimes we might
go into detail just because we can. But, what we shouldn't do is get stuck
in detail that may have to change later on.  We would be better served
resolving the higher level portions of the design first (remember the "*Most
*-*Constrained*-Variable-First" heuristic).  It is extremely important to
use this heuristic when working on such complicated design projects

Thoughts?

Dave



-------------------------------------------
AGI
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/
Modify Your Subscription: 
https://www.listbox.com/member/?member_id=8660244&id_secret=8660244-6e7fb59c
Powered by Listbox: http://www.listbox.com

Reply via email to