第 05 章 知识工程与专家系统 人工智能课件

第五章知识工程与专家系统

5.1专家系统概述

5.1.1 基本概念

5.1.2 专家系统的类型

5.1.3 专家系统的基本结构

5.1.4 元知识

5.1.5 专家系统开发方法

5.2LISP 语言简介

5.3知识库与推理机

5.3.1 规则的表示

5.3.2 推理机的实现示例

5.4 解释器的实现

5.5知识获取

5.5.1 知识获取的任务与方式

5.5.2 知识的检测与求精

5.7分布式专家系统与协同式专家系统

5.7.1 分布式专家系统及其驱动方式

5.7.2 协同式专家系统及其协同方法作业

5.1.3 专家系统的基本结构（1）

人机接口知识库

解释器

状态数据库推理机

●目标知识：直接用于领域问题求解的知识。

●元知识：关于目标知识的知识，包括获取目标知识的知识和使用目标知识的知识。

●目标级推理

●元级推理

●元知识的用途：（过程型、描述型）（1）知识获取

（2）控制知识的使用

原型系统

1、演示原型

仅能解决少量典型问题

2、研究原型

能解决较多问题，但不够稳定，具有面向开发的辅助功能，如测试、解释

LISP 简介

例：求m n

m0=1

m n=m×m n-1(n＞0)

(defun power_1(m n)

(cond((=n0)1)

(t(*m(power_1m(-n1))))))

n 阶Hanoi 塔算法( LISP )

(defun hanoi(n x y z)

(cond((=n1)(move_disk x y))

(T(hanoi(-n1)x z y)

(move_disk x n y)

(hanoi(-n1)z y x)))) (hanoi'A'B'C3)

11、高阶函数（函数的参数为函数）

例1：计算m2+(m+1)2+……+n2

(defun square(x)(*x x))

(defun sum-squares(m n)

(cond((>m n)0)

(t(+(square m)

(sum-squares(+m1)n)))))

●调用函数的函数：APPLY

(APPLY'函数名'(参数

1参数

2

……参数

n

))

●例：

(apply'+'(23)) 5

例2：计算例1的通用函数

(defun sum-items(func m n)

(cond((>m n)0)

(t(+(apply func(list m))

(sum-items func(+m1)n)))))调用示例：

(sum-items‘square13)

5.3知识库与推理机

5.3.1规则的表示

（不精确规则的表示与使用参第六章）

1、规则的等价变换

规则的等价变换

●已知规则：

R:[(F 1∧F 2∧F 3)∨(F 4∧F 5)]→H 1∧H 2（勘误）●R 可等价变换为下述4条规则：

R 1:(F 1∧F 2∧F 3)→H 1

R 2:(F 1∧F 2∧F 3)→H 2

R 3:(F 4∧F 5)→H 1

R 4:(F 4∧F 5)→H 2

2. 规则的LISP 表示

(规则名

(if（条件1）（条件2）………（条件n）) (then（结论1）（结论2）………（结论m）))或：

(规则名

(（条件1）（条件2）………（条件n）)

(（结论1）（结论2）………（结论m）))

正向推理机

（4）函数test_if

(defun test_if(rule)

(prog(ifs)

(setq ifs(cdadr rule))

loop

(cond((null ifs)(return t))

((recall(car ifs)))

(t(return nil)))

(setq ifs(cdr ifs))

(go loop)))

（2）函数verify

(defun verify(fact)

(prog(relevant1relevant2)

(cond((recall fact)(return t)))

(setq relevant1(inthen fact))

(setq relevant2relevant1)

(cond((null relevant1)

(cond((member fact asked)(return nil))

((and(print|IS THIS TRUE:|fact)(read))

(remember fact)(return t))

(t(setq asked(cons fact asked))

(return nil)))))

……………（转下页）

……………（接上页）loop1

(cond((null relevant1)(go loop2))

((try_rule(car relevant1))(return t))) (setq relevant1(cdr relevant1))

(go loop1)

loop2

(cond((null relevant2)(return nil))

((try_rule+(car relevant2))(return t))) (setq relevant2(cdr relevant2))

(go loop2)))