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