I think choosing an architecture for AGI is a much more important problem than 
choosing a language.  But there are some things we already know about AGI.  
First, AGI requires a vast amount of knowledge, and therefore a vast amount of 
computation.  Therefore, at least part of the AGI will have to be implemented 
in a fast (perhaps parallel) language.  Second, if you plan on having a team of 
programmers do the work (rather than all by yourself) then you will have to 
choose a widely known language.

Early work in AI used languages like Lisp or Prolog to directly express 
knowledge.  Now we all know (except at Cycorp) that this does not work.  There 
is too much knowledge to code directly.  You will need a learning algorithm and 
training and test data.

The minimum requirement for AGI is a language model, which requires about 10^9 
bits of information (based on estimates by Turing and Landauer, and the amount 
of language processed by adulthood).  When you add vision, speech, robotics, 
etc., it will be more.  We don't know how much, but if we use the human brain 
as a model, then one estimate is the number of synapses (about 10^13) 
multiplied by the access rate (10 Hz) = 10^14 operations per second.  But these 
numbers are really just guesses.  Perhaps they are high, but people have been 
working
on computational shortcuts for the last 50 years without success.

My work is in data compression, which I believe is an AI problem.  (You might 
disagree, but first see my argument at 
http://cs.fit.edu/~mmahoney/compression/rationale.html ).  Whether or not you 
agree, compression, like AGI, requires a great deal of memory and CPU.  Many of 
the top compressors ranked in my benchmark are open source, and of those, the 
top languages are C++ followed by C and assembler.  I don't know of any written 
in Java, C#, Python, or any interpreted languages, or any that use relational 
databases.

AGI is amenable to parallel computation.  Language, vision, speech, and 
robotics all involve combining thousands of soft constraints.  This requires 
vector operations.  The fastest way to do this on a PC is to use the parallel 
MMX and SSE2 instructions (or a GPU) that are not accessible in high level 
languages.  The 16-bit vector dot product that I implemented in MMX as part of 
the neural network used in the PAQ compressor is 6 times faster than optimized 
C.  Fortunately you do not need a lot of assembler, maybe a couple hundred 
lines of code to do most of the work.

AGI is still an area of research.  Not only do you need fast implementations so 
your experiments finish in reasonable time, but you will need to change your 
code many times.  Train, test, modify, repeat.  Your code has to be both 
optimized and structured so that it can be easily changed in ways you can't 
predict.  This is hard, but unfortunately we do not know yet what will work.  
 
-- Matt Mahoney, [EMAIL PROTECTED]


-----
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

Reply via email to