lisp - AI中的Lisp: self 修改代码和特定领域的抽象级别

Question

Closed. This question needs to be more focused. It is not currently accepting answers. Learn more。
想改进这个问题吗更新问题，使其只关注一个问题 editing this post。
三年前关闭。
AI是用各种不同的语言实现的，例如Python、C/C++、Java，所以有人能向我解释一下使用LISP究竟如何允许一个人执行Peter Norvig 5（在这里提到的）：
[Lisp允许..]一个宏系统，允许开发人员创建
构建下一层的抽象... 今天，（5）是
Lisp唯一一个优于其他语言的特性
语言。
来源： https://www.quora.com/Is-it-true-that-Lisp-is-highly-used-programming-language-in-AI
我基本上对创建特定于域的抽象级别的含义感到困惑请有人提供一个具体的例子/应用程序，说明这在什么时候/如何有用，一般来说，这意味着什么我试着阅读 http://lambda-the-ultimate.org/node/4765但并没有真正“了解全局”，然而，我觉得这里有某种魔力，因为Lisp允许您编写其他过程/面向对象/函数式语言不允许您编写的代码然后我看到了这篇文章： https://www.quora.com/Which-programming-language-is-better-for-artificial-intelligence-C-or-C++，上面的答案是：
对于通用人工智能，我不会选择
用LISP编写程序真正的人工智能会有很多自我修改的代码
（你不认为真正的人工智能会把程序员写的东西当作
最后一句话，好吗？）是的。
这让我更感兴趣，这让我想：
对于一个人工智能来说，拥有“自我检查、自我修改的代码”（源代码： Why is Lisp used for AI?）到底意味着什么，再说一遍，为什么/如何使用它？这听起来很酷（可以说，似乎人工智能对自己的操作是自觉的），而且听起来使用Lisp可以让人完成这类事情，而其他语言甚至都不会梦想它（很抱歉，如果这是天真的快乐，我对Lisp完全没有经验，但很高兴开始）我读了一点： What are the uses of self modifying code?并立即对特定人工智能应用的前景和未来自我修改代码的前沿产生了兴趣。
不管怎样，我可以肯定地看到在你的特定研究问题领域中，有能力编写自我修改的代码和有能力定制语言之间的联系（这是我在Peter Norvig的文章中所暗示的），但是我真的很不确定这到底意味着什么，我想理解螺母和螺栓（甚至仅仅是本质），以一种清晰的方式呈现上述两个方面（“特定领域抽象层”和“自我检查、自我修改代码”）。

最佳答案

[Lisp允许..]一个宏系统，允许开发人员创建特定于域的抽象级别，以便在其中构建下一个级别... 今天，（5）是Lisp与其他语言相比唯一的优势。
这对于堆栈溢出来说可能太宽泛了，但是领域特定抽象的概念在很多语言中都有，在普通的Lisp中要容易得多例如，在C语言中，当调用open（）时，会返回一个文件描述符。它是一个小整数，但是如果你坚持域模型，你不在乎它是一个整数，你在乎它是一个文件描述符，在需要文件描述符的地方使用它是有意义的不过，这是一个leaky abstraction，因为这些调用倾向于通过返回负整数来表示错误，所以实际上您必须关心文件描述符是整数这一事实，这样您就可以可靠地比较结果并判断它是否是错误在C语言中，可以定义将某些信息捆绑在一起的结构或记录类型这提供了稍高的抽象量。
抽象的概念是，你可以思考一些东西应该如何被使用，它代表什么，并且从领域的角度思考，而不是从表示的角度。所有的编程语言在某种意义上都支持这一点，但是Common Lisp使构建类似于语言内置的语言结构变得更加容易，并且有助于避免冗余（和容易出错的）样板文件。
例如，如果你正在编写一个定理证明器，你需要定义一系列的推理规则，并使它们成为一个可用的证明系统其中一些规则将更加简单，不需要知道当前的证明范围例如，要检查连词消元的用法（从a∧B，推断a（或B））是否合法，只需要检查前提和结论的形式如果没有抽象，您可能必须编写：

(defun check-conjunction-elimination (premises conclusion context)
   (declare (ignore context))
   (and (= (length premises) 1)
        (typep (first premises) 'conjunction)
        (member conclusion (conjunction-conjuncts (first premises))
                :test 'proposition=)))

(register-inference-rule "conjunction elimination" 'check-conjunction-elimination)

有了定义抽象的能力，您可以编写一个模式匹配器，可以将其简化为：

(defun check-conjunction-elimination (premises conclusion context)
   (declare (ignore context))
   (proposition-case (premises conclusion)
     (((and A B) A) t)
     (((and A B) B) t)))

(register-inference-rule "conjunction elimination" 'check-conjunction-elimination)

（当然，有些语言内置了模式匹配（Haskell，Prolog（某种意义上）），但重点是模式匹配是一个过程过程，您可以用任何语言实现它但是，这是一个代码生成过程，在大多数语言中，您必须在编译期间作为单独的过程来生成代码使用普通的Lisp，它是语言的一部分。）
你可以把这种模式抽象成：

(define-simple-inference-rule "conjunction elimination" (premises conclusion)
  ((and A B) A)
  ((and A B) B)))

你仍然可以生成原始代码这种抽象节省了很多空间，这意味着当其他人进来时，他们不需要知道所有常用的Lisp，只需要知道如何使用define simple inference rule（当然，这确实增加了一些开销，因为这是他们确实需要知道如何使用的其他东西。）但想法仍然存在：代码对应于您谈论域的方式，而不是编程语言的工作方式。
至于“自我修改代码”，我认为这是一个术语，你会听到比你实际看到的更好的用途。在上面描述的宏扩展的意义上，有一种自我修改代码（宏扩展代码知道如何“修改”或将代码转换成其他代码，但我不认为这是一个很好的例子）。既然您可以访问eval，那么您可以将代码作为一个对象进行修改并对其进行求值，但我认为没有多少人真正提倡这样做能够动态地重新定义代码是很方便的，但是，我想你会看到人们在repl中做的比在程序中做的要多得多。
然而，能够返回闭包（越来越多的语言支持的闭包）是一个很大的帮助例如， natural deduction style是“某种”自我修改你可以这样实现它：

(defmacro trace (name)
  (let ((f (symbol-function name)))
    (setf (symbol-function name)
          (lambda (&rest args)
            (print (list* name args))
            (apply f args)))))

您需要做更多的事情来支持untrace，但我认为这一点是相当清楚的；您可以在运行时以可预测的方式做一些改变函数行为等的事情。跟踪和日志记录工具是一个简单的例子，但是如果系统决定分析一些它知道很重要的方法，它可以动态地决定开始缓存一些结果，或者做其他有趣的事情这是一种“自我修正”，可能会很有帮助。

关于lisp - AI中的Lisp: self 修改代码和特定领域的抽象级别，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36416532/

上一篇：multithreading - Lparallel.queue 线程安全吗？

下一篇：lisp - SBCL 中的 bignum 乘法

相关文章：

list - 从 lisp 中的列表中评估函数

python - 在深度优先搜索中跟踪和返回路径

java - 我要做一个人工神经网络项目，我更喜欢哪种语言

algorithm - map 应用的聚类算法

java - 使用 IDDFS 和 GreedyBFS 的食人者和传教士

Lisp 链接函数宏

for-loop - cl-loop 破坏性地修改 cons 单元格

compiler-construction - 编译成惯用的 C

lisp - Scheme (Lazy Racket) 自然数的无限列表

C# Math.Net 矩阵维度必须一致

Answer 1

[Lisp允许..]一个宏系统，允许开发人员创建特定于域的抽象级别，以便在其中构建下一个级别... 今天，（5）是Lisp与其他语言相比唯一的优势。
这对于堆栈溢出来说可能太宽泛了，但是领域特定抽象的概念在很多语言中都有，在普通的Lisp中要容易得多例如，在C语言中，当调用open（）时，会返回一个文件描述符。它是一个小整数，但是如果你坚持域模型，你不在乎它是一个整数，你在乎它是一个文件描述符，在需要文件描述符的地方使用它是有意义的不过，这是一个leaky abstraction，因为这些调用倾向于通过返回负整数来表示错误，所以实际上您必须关心文件描述符是整数这一事实，这样您就可以可靠地比较结果并判断它是否是错误在C语言中，可以定义将某些信息捆绑在一起的结构或记录类型这提供了稍高的抽象量。
抽象的概念是，你可以思考一些东西应该如何被使用，它代表什么，并且从领域的角度思考，而不是从表示的角度。所有的编程语言在某种意义上都支持这一点，但是Common Lisp使构建类似于语言内置的语言结构变得更加容易，并且有助于避免冗余（和容易出错的）样板文件。
例如，如果你正在编写一个定理证明器，你需要定义一系列的推理规则，并使它们成为一个可用的证明系统其中一些规则将更加简单，不需要知道当前的证明范围例如，要检查连词消元的用法（从a∧B，推断a（或B））是否合法，只需要检查前提和结论的形式如果没有抽象，您可能必须编写：

(defun check-conjunction-elimination (premises conclusion context)
   (declare (ignore context))
   (and (= (length premises) 1)
        (typep (first premises) 'conjunction)
        (member conclusion (conjunction-conjuncts (first premises))
                :test 'proposition=)))

(register-inference-rule "conjunction elimination" 'check-conjunction-elimination)

有了定义抽象的能力，您可以编写一个模式匹配器，可以将其简化为：

(defun check-conjunction-elimination (premises conclusion context)
   (declare (ignore context))
   (proposition-case (premises conclusion)
     (((and A B) A) t)
     (((and A B) B) t)))

(register-inference-rule "conjunction elimination" 'check-conjunction-elimination)

（当然，有些语言内置了模式匹配（Haskell，Prolog（某种意义上）），但重点是模式匹配是一个过程过程，您可以用任何语言实现它但是，这是一个代码生成过程，在大多数语言中，您必须在编译期间作为单独的过程来生成代码使用普通的Lisp，它是语言的一部分。）
你可以把这种模式抽象成：

(define-simple-inference-rule "conjunction elimination" (premises conclusion)
  ((and A B) A)
  ((and A B) B)))

你仍然可以生成原始代码这种抽象节省了很多空间，这意味着当其他人进来时，他们不需要知道所有常用的Lisp，只需要知道如何使用define simple inference rule（当然，这确实增加了一些开销，因为这是他们确实需要知道如何使用的其他东西。）但想法仍然存在：代码对应于您谈论域的方式，而不是编程语言的工作方式。
至于“自我修改代码”，我认为这是一个术语，你会听到比你实际看到的更好的用途。在上面描述的宏扩展的意义上，有一种自我修改代码（宏扩展代码知道如何“修改”或将代码转换成其他代码，但我不认为这是一个很好的例子）。既然您可以访问eval，那么您可以将代码作为一个对象进行修改并对其进行求值，但我认为没有多少人真正提倡这样做能够动态地重新定义代码是很方便的，但是，我想你会看到人们在repl中做的比在程序中做的要多得多。
然而，能够返回闭包（越来越多的语言支持的闭包）是一个很大的帮助例如， natural deduction style是“某种”自我修改你可以这样实现它：

(defmacro trace (name)
  (let ((f (symbol-function name)))
    (setf (symbol-function name)
          (lambda (&rest args)
            (print (list* name args))
            (apply f args)))))

您需要做更多的事情来支持untrace，但我认为这一点是相当清楚的；您可以在运行时以可预测的方式做一些改变函数行为等的事情。跟踪和日志记录工具是一个简单的例子，但是如果系统决定分析一些它知道很重要的方法，它可以动态地决定开始缓存一些结果，或者做其他有趣的事情这是一种“自我修正”，可能会很有帮助。