Python人工智能——逻辑编程

本章我们将重点介绍逻辑编程及其在人工智能中的作用。

我们已经知道，逻辑是研究正确推理原则的学科，简单来说，就是研究事物前后关系的学科。例如，如果两个陈述为真，我们可以从中推断出任何第三个陈述。

概念

逻辑编程是逻辑和编程两个词的组合。逻辑编程是一种编程范式，其中问题通过程序语句以事实和规则的形式表达，但在形式逻辑系统内。就像其他编程范式（如面向对象、函数式、声明式和过程式等）一样，它也是一种特定的编程方法。

如何用逻辑编程解决问题

逻辑编程使用事实和规则来解决问题。这就是为什么它们被称为逻辑编程的构建块。逻辑编程中的每个程序都需要指定一个目标。要理解如何在逻辑编程中解决问题，我们需要了解构建块——事实和规则——

事实

实际上，每个逻辑程序都需要事实来运行，以便实现既定目标。事实基本上是关于程序和数据的真实陈述。例如，德里是印度的首都。

规则

实际上，规则是可以让我们对问题领域做出结论的约束。规则基本上写成逻辑子句来表达各种事实。例如，如果我们正在构建任何游戏，那么必须定义所有规则。

规则对于解决逻辑编程中的任何问题都非常重要。规则基本上是能够表达事实的逻辑结论。以下是规则的语法：

A∶− B1,B2,...,B_n。

这里，A是头部，B1, B2, ... Bn是主体。

例如：

ancestor(X,Y) :- father(X,Y).

ancestor(X,Z) :- father(X,Y), ancestor(Y,Z).

安装有用的包

要在Python中开始逻辑编程，我们需要安装以下两个包：

Kanren

它为我们提供了一种简化业务逻辑代码编写方式的方法。它允许我们用规则和事实来表达逻辑。以下命令将帮助您安装kanren：

pip install kanren

SymPy

SymPy是一个用于符号数学的Python库。它的目标是成为一个功能齐全的计算机代数系统(CAS)，同时保持代码尽可能简单，以便易于理解和扩展。以下命令将帮助您安装SymPy：

pip install sympy

逻辑编程示例

以下是可以用逻辑编程解决的一些示例：

匹配数学表达式

实际上，我们可以用非常有效的方式使用逻辑编程来查找未知值。以下Python代码将帮助您匹配数学表达式：

首先考虑导入以下包：

from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative

我们需要定义我们将要使用的数学运算：

add = 'add'
mul = 'mul'

加法和乘法都是交换过程。因此，我们需要指定它，这可以通过以下方式完成：

fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)

必须定义变量；这可以通过以下方式完成：

a, b = var('a'), var('b')

我们需要将表达式与原始模式匹配。我们有以下原始模式，它基本上是(5+a)*b：

Original_pattern = (mul, (add, 5, a), b)

我们有以下两个表达式与原始模式匹配：

exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))

可以使用以下命令打印输出：

print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))

运行此代码后，我们将获得以下输出：

((3,2))
()

第一个输出表示a和b的值。第一个表达式与原始模式匹配并返回了a和b的值，但第二个表达式与原始模式不匹配，因此没有返回任何内容。

检查素数

借助逻辑编程，我们可以从数字列表中找到素数，也可以生成素数。下面给出的Python代码将从数字列表中找到素数，并将生成前10个素数。

首先让我们考虑导入以下包：

from kanren import isvar, run, membero
from kanren.core import success, fail, goaleval, condeseq, eq, var
from sympy.ntheory.generate import prime, isprime
import itertools as it

现在，我们将定义一个名为prime_check的函数，该函数将根据给定的数字作为数据来检查素数。

def prime_check(x):
if isvar(x):
   return condeseq([(eq,x,p)] for p in map(prime, it.count(1)))
else:
   return success if isprime(x) else fail

现在，我们需要声明一个将要使用的变量：

x = var()
print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,41,44,52,62,65,85)),
(prime_check,x)))))
print((run(10,x,prime_check(x))))

上述代码的输出如下：

{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

解决谜题

逻辑编程可以用来解决许多问题，例如8数码难题、斑马难题、数独、N皇后等。这里我们以斑马难题的一个变体为例，如下所示：

There are five houses.
The English man lives in the red house.
The Swede has a dog.
The Dane drinks tea.
The green house is immediately to the left of the white house.
They drink coffee in the green house.
The man who smokes Pall Mall has birds.
In the yellow house they smoke Dunhill.
In the middle house they drink milk.
The Norwegian lives in the first house.
The man who smokes Blend lives in the house next to the house with cats.
In a house next to the house where they have a horse, they smoke Dunhill.
The man who smokes Blue Master drinks beer.
The German smokes Prince.
The Norwegian lives next to the blue house.
They drink water in a house next to the house where they smoke Blend.

我们正在使用Python来解决谁拥有斑马这个问题。

让我们导入必要的包：

from kanren import *
from kanren.core import lall
import time

现在，我们需要定义两个函数——left()和next()来检查谁的房子在谁的房子左边或右边：

def left(q, p, list):
   return membero((q,p), zip(list, list[1:]))
def next(q, p, list):
   return conde([left(q, p, list)], [left(p, q, list)])

现在，我们将声明一个名为house的变量，如下所示：

houses = var()

我们需要使用lall包定义规则，如下所示。

共有5所房子：

rules_zebraproblem = lall(
   (eq, (var(), var(), var(), var(), var()), houses),

   (membero,('Englishman', var(), var(), var(), 'red'), houses),
   (membero,('Swede', var(), var(), 'dog', var()), houses),
   (membero,('Dane', var(), 'tea', var(), var()), houses),
   (left,(var(), var(), var(), var(), 'green'),
   (var(), var(), var(), var(), 'white'), houses),
   (membero,(var(), var(), 'coffee', var(), 'green'), houses),
   (membero,(var(), 'Pall Mall', var(), 'birds', var()), houses),
   (membero,(var(), 'Dunhill', var(), var(), 'yellow'), houses),
   (eq,(var(), var(), (var(), var(), 'milk', var(), var()), var(), var()), houses),
   (eq,(('Norwegian', var(), var(), var(), var()), var(), var(), var(), var()), houses),
   (next,(var(), 'Blend', var(), var(), var()),
   (var(), var(), var(), 'cats', var()), houses),
   (next,(var(), 'Dunhill', var(), var(), var()),
   (var(), var(), var(), 'horse', var()), houses),
   (membero,(var(), 'Blue Master', 'beer', var(), var()), houses),
   (membero,('German', 'Prince', var(), var(), var()), houses),
   (next,('Norwegian', var(), var(), var(), var()),
   (var(), var(), var(), var(), 'blue'), houses),
   (next,(var(), 'Blend', var(), var(), var()),
   (var(), var(), 'water', var(), var()), houses),
   (membero,(var(), var(), var(), 'zebra', var()), houses)
)

现在，使用前面的约束运行求解器：

solutions = run(0, houses, rules_zebraproblem)

借助以下代码，我们可以从求解器中提取输出：

output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]

以下代码将帮助打印解决方案：

print ('\n'+ output_zebra + 'owns zebra.')

上述代码的输出如下：

German owns zebra.

打印页面