Ben:
In mathematics, there is the concept of "complete sets of functions"
which has many actual realizations, eg, Bessel functions, etc.

This raises the idea that there could possibly be complete sets
of algorithms.  If different sets can be given the task to approximate
behavior, in parallel, and in analogy to CSFs, some approximating
algorithm would probably win the race and terminate the search
for the needed algorithm.  But this presupposes the existence of
known complete algorithm sets; I don't recall the establishment
of the existence of such sets.

Cheers, Gene

On 2/8/2013 10:38 AM, Ben Goertzel wrote:

"Automated program learning" is a branch of AI that seems close to what you 
have in
mind...

This is what the MOSES component of OpenCog attempts to do, though it's 
currently
only really effective at learning simple sorts of programs...

-- Ben G

On Fri, Feb 8, 2013 at 10:22 AM, Jim Bromer <[email protected]
<mailto:[email protected]>> wrote:

    I was wondering if an algorithm generator might be useful for an AGI 
project.A
    super algorithm generator probably would not be so good because of the 
number of
    parameters that would be required to denote a collection of particular
    (generated) algorithms which had been found to be useful.If multiple 
algorithm
    generators were used, most of which were able to generate algorithms that 
could
    interact with the other kinds of algorithms that were generated, then each
    generator would need fewer parameters and you would only need to define the
    parameters for those combinations which were needed.Another way is to use a 
few
    super generators where each parameter that was used would have to be 
explicitly
    designated and those that weren't designated could just be ignored.

    The reason an algorithm generator might be useful because it might make 
sense to
    generate only those algorithms which were needed without creating millions 
of
    other algorithms which were not very useful.We all keep seeing how narrow 
AI can
    be achieved and there are reasons to believe that using many individual
    algorithms to analyze and decipher data and derive other related data may 
be the
    way to go.

    Let me explain why I thought that a super algorithm generator could be used 
in a
    concise manner.I originally was trying to think of an algorithm that did 
not take
    any input but which could create an overwhelming number of different 
variations
    of a typographical character.I wondered how I might program the generator
    effectively to convince a skeptic that it was capable of producing an 
immensity
    of different variations.I was worried that if it simply iterated its way 
through
    the parameters that it would get stuck on one variation and it might look 
like it
    was just producing the same kind of variations of one style over and over
    again.(This is what happens when a great video game starts to bore you).So 
I came
    up with the use of random number generators to generate the 
parameters.Another
    method is to use a number generator that can produce non-sequential string 
of
    numbers which did not begin outputting a repeating substring (like a decimal
    expansion of a rational number).I don't know how to do this efficiently but 
I
    believe that there may be some way.

    So the super algorithm generator probably would not work well in an AGI 
program
    because it would not be efficient to implement it under the demands of a
    practical system.However, the component algorithm generators might make more
    sense and it is an interesting idea to think about.I can describe a toy 
model,
    but it will seem so familiar that some programmers might think that they had
    already thought of using algorithm generators in their programming just 
because
    they have so much personal experience generating variations of algorithms.

    Suppose you are analyzing an image and your algorithm is not working 
because of
    the pixilation.What do you do?I tried a blurring algorithm to blur the image
    slightly.So by taking 4 pixels in a square (or 9 or 16) and averaging them 
out I
    can reduce the pixilation a little bit.This could be done by changing the
    parameters in a rgb algorithm generator.If an AGi program was able to 
develop
    some kind of reasoning about a problem and its attention was directed toward
    pixilation it might be able to notice that blur algorithms can reduce 
pixilation.
    However, the blur algorithm did not work for my problem. I was trying to 
extend
    the abilities of a line drawing algorithm and the simple blur algorithm 
blurred
    the very kinds of lines that I was looking for.So, in order to try to make 
sure
    that I do not blur the distinctiveness between shapes I am going to try to 
make 9
    different 4 pixel blurs so that each pixel will be grouped with different
    compositions of neighboring pixels.This way I might be able to detect a 
strong
    contrast line or a demarcation between different colored shapes.

    This toy problem shows how the algorithm generator might work if some 
essential
    reasoning between a desired goal and actual results could be made on the 
basis of
    a collection of observations of how individual rgb algorithms act on various
    images.One of the problems in AI is that we do not know how to take the
    'observation' of directly inputted data to discover the meaning of that 
data and
    how it relates to other data objects. However, the substitution of a goal is
    often easier.Once attention is drawn to some effect, the goal of recreating 
that
    effect in other situations may be something that a simple AGi program can
    realize.So if a goal is clearly definable (for an AGi program) and there are
    examples of generated algorithms that were capable of reaching the desired
    effect for some cases and there was some basis for believing that an 
modification
    of some group of parameters might enhance the desired characteristics of 
those
    algorithms for the more difficult cases, then this idea might be 
useful.Another
    reason that this idea of algorithm generators might be useful is because 
they
    might be used to standardize processes of discovery in an AGI program.So I 
am
    going to continue thinking about this.

    Jim Bromer

    *AGI* | Archives <https://www.listbox.com/member/archive/303/=now>
    <https://www.listbox.com/member/archive/rss/303/212726-deec6279> | Modify
    <https://www.listbox.com/member/?&;> Your Subscription     [Powered by 
Listbox]
    <http://www.listbox.com>




--
Ben Goertzel, PhD
http://goertzel.org

"My humanity is a constant self-overcoming" -- Friedrich Nietzsche
*AGI* | Archives <https://www.listbox.com/member/archive/303/=now>
<https://www.listbox.com/member/archive/rss/303/12987897-64924e57> | Modify
<https://www.listbox.com/member/?&;> Your
Subscription    [Powered by Listbox] <http://www.listbox.com>




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

Reply via email to