是否有迭代编写新程序的程序?
大约一年来我一直在考虑编写一个可以编写程序的程序。这主要是一个有趣的练习,可能会教我一些新概念。我的灵感来自负熵以及从混乱中产生秩序以及从混乱中产生新的混乱的能力无限连续的顺序。
更具体地说,该程序将首先写入一个短的随机字符串。如果字符串编译,程序将记录它以供以后比较。如果字符串未编译,程序将尝试重写它,直到编译为止。随着更多字符串(迷你“无用”程序)被记录,它们可以被解析以查找相似性并用于生成语法。然后可以利用该语法来编写更多比纯随机字符串具有更高编译概率的字符串。
这显然有点愚蠢,但我认为尝试开发这样的程序会很有趣。作为副产品,我得到了一堆独特的程序,我可以将它们可视化并称之为艺术。
由于其简单的语法和动态编译,我可能会用 Ruby 编写此代码,然后我将使用 ruby 处理来可视化处理过程。
我想知道的是:
- 这种类型的编程有名称吗?
- 目前该领域存在什么?
- 主要贡献者是谁?
- 奖金! - 除了编译之外,我可以通过哪些方式在程序上为输出程序赋值(y/n)?
我可能想扩展该程序的功能以生成基于参数的程序,但我希望该程序通过运行编译的程序并为程序输出分配含义来定义这些参数。这个问题可能比奖金的合理性更复杂,但如果您能想出一种简单的方法来在不到 23 行或一个超链接的时间内完成类似的事情,请把它扔到您的回复中。
我知道这不完全是元编程,根据我对人工智能和生成算法的了解,它们通常比我想象的更以目标为导向。最好的是一个能够不断重写和改进自身的程序,这样我就不必^_^
For about a year I have been thinking about writing a program that writes programs. This would primarily be a playful exercise that might teach me some new concepts. My inspiration came from negentropy and the ability for order to emerge from chaos and new chaos to arise out of order in infinite succession.
To be more specific, the program would start by writing a short random string. If the string compiles the programs will log it for later comparison. If the string does not compile the program will try to rewrite it until it does compile. As more strings (mini 'useless' programs) are logged they can be parsed for similarities and used to generate a grammar. This grammar can then be drawn on to write more strings that have a higher probability of compilation than purely random strings.
This is obviously more than a little silly, but I thought it would be fun to try and grow a program like this. And as a byproduct I get a bunch of unique programs that I can visualize and call art.
I'll probably write this in Ruby due to its simple syntax and dynamic compilation and then I will visualize in processing using ruby-processing.
What I would like to know is:
- Is there a name for this type of programming?
- What currently exists in this field?
- Who are the primary contributors?
- BONUS! - In what ways can I procedurally assign value to output programs beyond compiles(y/n)?
I may want to extend the functionality of this program to generate a program based on parameters, but I want the program to define those parameters through running the programs that compile and assigning meaning to the programs output. This question is probably more involved than reasonable for a bonus, but if you can think of a simple way to get something like this done in less than 23 lines or one hyperlink, please toss it into your response.
I know that this is not quite meta-programming and from the little I know of AI and generative algorithms they are usually more goal oriented than what I am thinking. What would be optimal is a program that continually rewrites and improves itself so I don't have to ^_^
如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱,如果其他用户或者作者回复了您的评论,将不能在第一时间通知您!
发布评论
评论(6)
查找“基因编程”。
编辑以回复评论:
@chris,@Kasturi:正确。 OP中描述的是一个通过暴力尝试编译某些具体语法来推断语法的系统,然后从该语法中反向生成新的具体语法。如果您一定有一些与该描述非常匹配的东西......我最好的建议是考虑使用某种语言的具体语法以非常少的语法构建隐藏的马尔可夫模型。我会考虑使用最小的组合逻辑(本质上类似于 Unlambda 语言)。
另一方面,遗传编程是一种具有一定成熟实践和文献的技术,并且不是“确定性”的,而是一个随机过程。这也是一个相当广泛的术语——可以说 OP 系统是 GP 的一个极限情况,具有 0% 交叉和 100% 突变。
Look up "genetic programming."
Edit to respond to comments:
@chris, @Kasturi: true. What was described in the OP is a system for inferring a grammar by brute-force attempts to make some concrete syntax compile, and then back-generating new concrete syntax from the grammar. If you're bound to have something very closely matching that description... the best advice I have is to look into building a hidden Markov model from concrete syntax in some language with very minimal syntax. I'd consider using a minimal combinatorial logic (something akin in spirit to the Unlambda language).
On the other hand, genetic programming is a technique with some developed practice and literature, and is not "deterministic" but rather a stochastic process. It's also a pretty broad term---arguably the system of the OP is a limiting case of GP with 0% crossover and 100% mutation.
您听说过nanopond吗?这个概念和你的类似。每个像素都有一个随机生成的字符串,该字符串通过编译器运行。通常,这不会产生任何有效的程序。然而,每隔一段时间,随机生成的字符串就会以某种方式完美地格式化,以便能够将其自身复制到相邻像素中。很快,这就变成了一场争夺哪个程序能够比另一个程序更好地重现的战斗。
是的,你所说的是遗传算法,但最大化一件事,而且只有一件事:繁殖能力。
这是所有自然发生的负熵现象的基本起源:随机形成的复杂实体具有繁殖能力。
经典遗传算法强加了人工繁殖标准——人工选择表现最好的程序来进行繁殖。
你所暗示的是一种计算自然选择。也就是说,程序将根据其自我复制的能力来进化,仅此而已。
这会创造出有用的东西吗?也许不是。除非您允许您的程序访问互联网或其他一些它们可以随机访问的外部 API,并且可能通过互联网传播。
不幸的是,您所描述的系统仍然有一些人为的复制标准:编译的能力。
因为编译能力=重现能力,所以你人为地将你的程序设置为朝着编译的方向发展。
编译什么?这并不重要,因为任何编译后的程序都可能像上一个程序一样重现。假设您以某种方式生成了一个可以输出斐波那契数列的程序。或者一个可以击败国际象棋大师的程序。凉爽的!不幸的是,它会被复制吗?会不会很特别?
一点也不;它会被视为“适合”复制,因为程序
print('k')
我建议也许操作一个随机运行的程序字符串框架,这些程序可以访问 API,这些 API 可以:
我认为编写可以自我复制的程序的程序比编写可以编译的程序可以产生更好的结果。
除非你只想要后者;那么也许你可以最大化程序长度。但有可能发生一些有趣的事情吗?没那么多;任何“编译”具有一定长度的程序都与“复制”一样可能。
Have you heard of nanopond? The concept is similar to yours. Every pixel is given a randomly generated string that is run through a compiler. Usually, this doesn't produce any valid program. However, every once in a while, a randomly generated string will somehow be formatted just perfectly to be able to reproduce itself into a neighboring pixel. Soon, it becomes a battle for which program can reproduce better than the other.
What you are talking about is a genetic algorithm, yes, but maximizing one thing and one thing alone: The ability to reproduce.
This is the essential origin to all naturally-occurring negentropic phenomenon: a randomly formed complex entity has the ability to reproduce.
Classical genetic algorithms impose artificial reproduction criteria -- the program that does a job the best is artificially chosen to reproduce.
What you are implying is a sort of computational natural selection. That is, programs will evolve based on their ability to reproduce themselves, and nothing more.
Will this create something useful? Perhaps not. Unless you, maybe, gave your programs access to the internet or some other external API that they can randomly access, and maybe spread over the internet.
Unfortunately, your described system still has somewhat artificial reproduction criteria: the ability to compile.
Because ability to compile = ability to reproduce, you have artificially set your programs to evolve towards compiling.
Compiling what? It doesn't matter, because any program that compiles is as likely to reproduce as the last. Let's say you somehow generated a program that would output the Fibonacci Sequence. Or a program that could beat a chess Grandmaster. Cool! Unfortunately, would it be reproduced? Would it be special?
Not at all; it'd be treated as "fit" for reproduction as the program
print('k')
I suggest perhaps operating a framework of randomly-running strings of programs that have access to API's that can:
I think a program that writes programs that can reproduce themselves could produce better results than a program which writes programs that can compile.
Unless you only want the latter; then maybe you could maximize program length. But the possibility of something interesting happening? Not that much; any program that "compiles" with a certain length would be just as likely as "reproducing".
您可以做的另一个项目是处理从未通过某个单元测试到通过单元测试的转变。
例如,给定一个实现,
您可以添加一个测试
,并要求您的程序尝试
add
中的a
上的方法的任意组合(例如,a.-( b)
、a.to_s
、a.+(b)
),直到其中一个突变体通过该测试和现有测试。您可能想查看 heckle (或 Zentest?)以获取更改正在测试的代码的示例。
A different project you could do is work on something that mutates from not passing a certain unit test to passing a unit test.
For example, given an implementation
You could add a test
and ask your program to try any combination of methods on
a
withinadd
(for example,a.-(b)
,a.to_s
,a.+(b)
) until one of the mutants passes that test and existing tests.You may want to look at heckle (or Zentest?) for examples of changing code being tested.
查找语法演变。
Look for Grammatical Evolution.
执行这些步骤:
Do these steps:
早期但非常有趣的作品是 Doug Lenat 的“AM”(数学家)和 Eurisko (AM 的概括)。
Eurisko 通过研究边界条件如何影响问题的解决,发展了一套色调学。它不会产生垃圾,而是尝试一下,相反,它采用了一种较弱的问题解决方法,发现了可以做得更好的情况,并生成了问题解决程序的修补版本。
Early but very interesting works along these lines was Doug Lenat's "AM" (A Mathematician) and Eurisko (an generalization of AM).
Eurisko evolved a set of hueristics by examining how boundary conditions affected solving a problem. It did not generate junk than then try it, rather, it took a weak problem solving method and found cases where it could a much better job, and produced a patched version of the problem solver.