1. 实验报告应包括：实验目的
熟悉一阶谓词逻辑和产生式表示法，掌握产生式系统的运行机制，以及基于规则推理的基本方法。
2. 实验内容
运用所学知识，设计并编程实现一个小型人工智能系统（如分类、诊断、预测等类型）。
3. 实验原理
（1）一个产生式系统由三个部分组成
1)综合数据库：用来存放与求解问题有关的数据以及推理过程环境的当前状态的描述。
2)产生式规则库：主要存放问题求解中的规则。
3)控制策略：其作用是说明下一步应该选用什么规则，也就是说如何应用规则。
三个部分如图所示：

（2）产生式系统的实现有三种方法
1)正向推理：从一组表示事实的谓词或命题出发，使用一组产生式规则，用以证明该谓词公式或命题是否成立。
2)逆向推理：从表示目标的谓词或命题出发，使用一组产生式规则证明事实谓词或命题成立，即首先提出一批假设目标，然后逐一验证这些假设。
3)双向推理：双向推理的推理策略是同时从目标向事实推理和从事实向目标推理，并在推理过程中的某个步骤，实现事实与目标的匹配。
4. 实验器材
····计算机
5. 实验步骤
基于如图1所示的产生式系统实验程序，设计并实现一个小型人工智能系统：
1）系统设置，包括设置系统名称和系统谓词，给出谓词名及其含义。
2）编辑知识库，通过输入规则或修改规则等，完成整个规则库的建立。
3）建立事实库（综合数据库），输入多条事实或结论。
4）运行推理，包括正向推理和反向推理，给出相应的推理过程、事实区和规则区。
6.代码
shengchanshi.m

%生产式系统
%要求部分
% R1：种子有果皮 -> 被子植物
% R2：种子无果皮 -> 裸子植物
% R3：无茎叶 & 无根 -> 藻类植物
% R4：被子植物 & 有托叶 -> 蔷薇科
% R5：被子植物 & 吸引菜粉蝶 -> 十字花科
% R6：被子植物 & 十字形花冠 -> 十字花科
% R7：被子植物 & 缺水环境 -> 仙人掌科
% R8：被子植物 & 蔷薇科 & 有刺 -> 玫瑰
% R9：被子植物 & 水生 & 可食用 & 结果实 -> 荷花
% R10：被子植物 & 仙人掌科 & 喜阳 & 有刺 -> 仙人球
% R11：藻类植物 & 水生 & 药用 -> 水棉
% R12：被子植物 & 蔷薇科 & 木本 & 可食用 & 结果实 -> 苹果树
% R13：被子植物 & 十字花科 & 黄色花 & 可食用 & 结果实 -> 油菜
% R14：藻类植物 & 水生 & 可食用 & 有白色粉末 -> 海带
% R15：裸子植物 & 木本 & 叶片针状 & 结果实 -> 松树
%% 代码部分

% 设定所有的陈述与结论
% set all statements and conclusions

disp('请根据特征输入1或0');
q=input('有果皮?');
state{1}.C = '有果皮';
if q==1
    state{1}.T = 1;
else
    state{1}.T = 0;
end

state{2}.C = '被子植物';
state{2}.T = 0;

q=input('无果皮?');
state{3}.C = '无果皮';
if q==1
    state{3}.T = 1;
else
    state{3}.T = 0;
end

state{4}.C = '裸子植物';
state{4}.T = 0;


q=input('无茎叶?');
state{5}.C = '无茎叶';
if q==1
    state{5}.T = 1;
else
    state{5}.T = 0;
end

q=input('无根?');
state{6}.C = '无根';
if q==1
    state{6}.T = 1;
else
    state{6}.T = 0;
end

state{7}.C = '藻类植物';
state{7}.T = 0;


q=input('有托叶?');
state{8}.C = '有托叶';
if q==1
    state{8}.T = 1;
else
    state{8}.T = 0;
end

state{9}.C = '蔷薇科';
state{9}.T = 0;

q=input('吸引菜粉蝶?');
state{10}.C = '吸引菜粉蝶';
if q==1
    state{10}.T = 1;
else
    state{10}.T = 0;
end


state{11}.C = '十字花科';
state{11}.T = 0;

q=input('十字形花冠?');
state{12}.C = '十字形花冠';
if q==1
    state{12}.T = 1;
else
    state{12}.T = 0;
end

q=input('缺水环境?');
state{13}.C = '缺水环境';
if q==1
    state{13}.T = 1;
else
    state{13}.T = 0;
end

state{14}.C = '仙人掌科';
state{14}.T = 0;


q=input('有刺?');
state{15}.C = '有刺';
if q==1
    state{15}.T = 1;
else
    state{15}.T = 0;
end

state{16}.C = '玫瑰';
 state{16}.T = 0;


q=input('水生?');
state{17}.C = '水生';
if q==1
    state{17}.T = 1;
else
    state{17}.T = 0;
end

q=input('可食用?');
state{18}.C = '可食用';
if q==1
    state{18}.T = 1;
else
    state{18}.T = 0;
end

q=input('结果实?');
state{19}.C = '结果实';
if q==1
    state{19}.T = 1;
else
    state{19}.T = 0;
end

state{20}.C = '荷花';
 state{20}.T = 0;


q=input('喜阳?');
state{21}.C = '喜阳';
if q==1
    state{21}.T = 1;
else
    state{21}.T = 0;
end

state{22}.C = '仙人球';
state{22}.T = 0;


q=input('药用?');
state{23}.C = '药用';
if q==1
    state{23}.T = 1;
else
    state{23}.T = 0;
end

state{24}.C = '水棉';
state{24}.T = 0;


q=input('木本?');
state{25}.C = '木本';
if q==1
    state{25}.T = 1;
else
    state{25}.T = 0;
end


state{26}.C = '苹果树';
state{26}.T = 0;

q=input('黄色花?');
state{27}.C = '黄色花';
if q==1
    state{27}.T = 1;
else
    state{27}.T = 0;
end

state{28}.C = '油菜';
state{28}.T = 0;


q=input('白色粉末?');
state{29}.C = '白色粉末';
if q==1
    state{29}.T = 1;
else
    state{29}.T = 0;
end

state{30}.C = '海带';
state{30}.T = 0;

q=input('叶片针状?');
state{31}.C = '叶片针状';
if q==1
    state{31}.T = 1;
else
    state{31}.T = 0;
end

state{32}.C = '松树';
state{32}.T = 0;

%% 打印初始的状态
% print initial status
fprintf('初始状态为:\n');
for i = 1 : length(state) 
        if state{i}.T == 1
        fprintf(state{i}.C);
        fprintf('，');
        end
end
fprintf('\n');

%% 生产式规则
% production rules
change = 1;
while change == 1
    change = 0;

    if JudgeState(state, '有果皮') && change == 0
        [change, state]  = TrueState(state, '被子植物' );
    end
    
    if JudgeState(state, '无果皮') && change == 0
        [change, state]  = TrueState(state, '裸子植物' );
    end    

    if JudgeState(state, '无茎叶') && JudgeState(state, '无根') && change == 0
        [change, state]  = TrueState(state, '藻类植物' );
    end 

    if JudgeState(state, '被子植物') && JudgeState(state, '有托叶') && change == 0
        [change, state]  = TrueState(state, '蔷薇科' );
    end   

    if JudgeState(state, '被子植物') && JudgeState(state, '吸引菜粉蝶') && change == 0
        [change, state]  = TrueState(state, '十字花科' );
    end   

    if JudgeState(state, '被子植物') && JudgeState(state, '十字形花冠')  && change == 0
        [change, state]  = TrueState(state, '十字花科' );
    end      
    
    if JudgeState(state, '被子植物') && JudgeState(state, '缺水环境')  && change == 0
        [change, state]  = TrueState(state, '仙人掌科' );
    end  

    if JudgeState(state, '被子植物') && JudgeState(state, '蔷薇科') && JudgeState(state, '有刺') && change == 0 
        [change, state]  = TrueState(state, '玫瑰' );
    end           
    
    if JudgeState(state, '被子植物') && JudgeState(state, '水生') && JudgeState(state, '可食用') && JudgeState(state, '结果实')  && change == 0
        [change, state]  = TrueState(state, '荷花' );
    end               
    
    if JudgeState(state, '被子植物') && JudgeState(state, '仙人掌科') && JudgeState(state, '喜阳') && JudgeState(state, '有刺') && change == 0 
        [change, state]  = TrueState(state, '仙人球' );
    end       
    
    if JudgeState(state, '藻类植物') && JudgeState(state, '水生') && JudgeState(state, '药用') && change == 0
        [change, state]  = TrueState(state, '水棉' );
    end 

    if JudgeState(state, '被子植物') && JudgeState(state, '蔷薇科') && JudgeState(state, '木本') && JudgeState(state, '可食用') && JudgeState(state, '结果实') && change == 0
        [change, state]  = TrueState(state, '苹果树' );
    end  

    if JudgeState(state, '被子植物') && JudgeState(state, '十字花科') && JudgeState(state, '黄色花') && JudgeState(state, '可食用') && JudgeState(state, '结果实')&& change == 0
        [change, state]  = TrueState(state, '油菜' );
    end  

    if JudgeState(state, '藻类植物') && JudgeState(state, '水生') && JudgeState(state, '可食用') && JudgeState(state, '白色粉末') && change == 0
        [change, state]  = TrueState(state, '海带' );
    end 
    
    if JudgeState(state, '裸子植物') && JudgeState(state, '木本') && JudgeState(state, '叶片针状') && JudgeState(state, '结果实') && change == 0
        [change, state]  = TrueState(state, '松树' );
    end 

    if change == 1
        fprintf('状态变化为:\n'); 
        
        for i = 1 : length(state)
            if state{i}.T == 1
            fprintf(state{i}.C);
            fprintf('，');
            end
        end
        fprintf('\n');
    end
end

两个子函数
JudgeState.m

function output = JudgeState(state, in)
% 生产式系统实验子函数
% 输入状态列表（state）与当前状态（in）
% 输出当前状态是否在状态列表中的判断结果 
output = 0;
    for i = 1: length(state)
        if strcmp(state{i}.C, in) && state{i}.T == 1
            output = 1;
            break;
        end
    end
end

TrueState.m

function [change, state] = TrueState(state, in)
% 生产式系统实验子函数
% 输入状态列表（state）与当前状态（in）
% 将输入状态的在状态列表中置为真
change = 0;
    for i = 1: length(state)
        if strcmp(state{i}.C, in) && state{i}.T == 0
            change  = 1;
            state{i}.T = 1;
            break;
        end
    end
end

若有问题或疑问，联系方式：820126751@qq.com

实验一 产生式系统实验

一、实验目的:熟悉一阶谓词逻辑和产生式表示法，掌握产生式系统的运行机制，以及基于规则推理的基本方法。
二、实验内容
设计并编程实现一个小型产生式系统（如:分类、诊断等类型)
三、实验要求
1.具体应用领域自选，具体系统名称自定。
2.用一阶谓词逻辑和产生式规则作为知识表示，利用产生式系统实验程序，建立知识库，分别运行正、反向推理。
四、实验报告要求
1.系统设置，包括系统名称和系统谓词，给出谓词名及其含义。
⒉.编辑知识库，通过输入规则或修改规则等建立规则库。
3.建立事实库（(综合数据库)，输入多条事实或结论。
4.运行推理，包括正向推理和反向推理，给出相应的推理过程、事实区和规则区。
5.总结实验心得体会。

1. 系统设置

系统名称：植物识别系统

谓词定义：

2. 编辑知识库

默认规则库：
R1：种子有果皮 -> 被子植物
R2：种子无果皮 -> 裸子植物
R3：无茎叶 & 无根 -> 藻类植物
R4：被子植物 & 有托叶 & 有刺 -> 玫瑰
R5：被子植物 & 水生 & 可食用 & 结果实 -> 荷花
R6：被子植物 & 缺水环境 & 有刺 -> 仙人球
R7：藻类植物 & 水生 & 药用 -> 水棉
R8：被子植物 & 有托叶 & 木本 & 可食用 & 结果实 -> 苹果树
R9：被子植物 & 吸引菜粉蝶 & 十字形花冠 & 黄色花 & 可食用 & 结果实 -> 油菜
R10：藻类植物 & 水生 & 可食用 -> 海带
R11：裸子植物 & 木本 & 叶片针状 & 结果实 -> 松树

3. 建立事实库（(综合数据库)

(1) 植物个体：
玫瑰、荷花、仙人球、水棉、苹果树、油菜、海带、松树。
(2) 区别个体的特征：
有刺、水生、喜阳、药用、木本、可食用、有白色粉末、叶片针状、结果实、黄色花。
(3) 区别种类的特征：
种子有果皮、种子无果皮、无茎叶、无根、有托叶、吸引菜粉蝶、十字形花冠、缺水环境。
(4) 种类：
被子植物、裸子植物、藻类植物、蔷薇科、十字花科、仙人掌科。

4. 运行推理

具体源码见：demo.java
https://download.csdn.net/download/hgxiaojiujiu/28342999

import java.util.*;

/**
 * 产生式系统 --- 植物识别系统
 *
 * @author  whj | CSDN@hgxiaojiujiu
 * 
 */
public class demo {
    //记录数据库植物特征
    public static final String data[] = {
            "有刺", "水生", "药用", "木本", "可食用", "叶片针状", "结果实", "黄色花",//区别个体的特征
            //0      1       2      3       4       5           6          7
            "种子有果皮", "种子无果皮", "无茎叶", "无根", "有托叶", "吸引菜粉蝶", "十字形花冠", "缺水环境",//区别种类的特征
            //  8           9         10      11      12          13         14          15
            "被子植物", "裸子植物", "藻类植物", //种类
            //  16          17         18
            "玫瑰", "荷花", "仙人球", "水棉", "苹果树", "油菜", "海带", "松树", "无此类植物"};  //植物个体
    // 19   20     21          22     23      24     25     26     27
    //规则
    public static Map<String, Integer> rule = new HashMap<>();

    //记录用户选择
    public static List<String> userList = new ArrayList<>();

    public static int plant = 0;

    public static Integer flag = 1;

    //系统运行入口
    public static void main(String[] args) {
        System.out.println("------------欢迎*植物识别系统*-------------");
        InitSys();
        System.out.println();
        while (flag == 1) {
            System.out.print("输入植物特征:");
            Scanner scanner = new Scanner(System.in);
            String choose = scanner.nextLine();
            //正向推理
            if (choose.length() > 3) {
                ChooseComputer_pos(choose);
                flag = 0;
                break;
            }
            // 结束
            if (Integer.parseInt(choose) == -1) {
                flag = 0;
                break;
            }
            userList.add(choose);
            ChooseComputer_rev(userList);  //条件逐步逆向推断
        }
        System.out.print("推理过程：");
        //推理显示
        for (String s : userList) {
            System.out.print(data[Integer.parseInt(s)] + "->");
        }
        System.out.print(data[plant]);

    }

已经明确植物的所有特征，直接得出植物

已知植物的部分特征，逐步推理

明确植物目标，但不明确植物特征进行推理

5 .总结实验心得体会。

本系统的规则库是静态的，不能很好的进行增删改操作，这使得在实际运用是不便于系统数据库的修改和维护，对于系统功能更方便地实现增加了一定难度。

基于产生式规则的动物识别系统

先放效果图

• 控制台

推理失败截图：
推理成功截图：

• MFC
  
  推理失败截图：
  
  推理成功界面：
  
  
  实验目的：
  熟悉一阶谓词逻辑和产生式表示法，掌握产生式系统的运行机制，以及基于规则推理的基本方法。运用所学知识，设计并编程实现一个基于产生式系统的小型专家系统
  实验要求：
  具体实验内容根据自己兴趣设计并实现一个基于产生式系统的某领域的小型专家系统。
  1.具体应用领域根据自己兴趣选择；具体系统名称自定；编程语言不限，使用自己擅长的语言。
  2.确定推理方法，根据问题设计并实现一个简单的推理机（要求涉及：匹配、冲突消解）。
  3.规则库要求至少包含15条规则；查询资料了解：知识规则如何存储，都有哪些可行方案和方法，选择、比较后确定适合自己系统的知识规则存储方法。
  4.推理机和知识库必须分离，在不修改推理机程序的前提下，能够向知识库添加、删除、修改规则。
  5.设计合理的人机交互界面。

功能设计与实现

1. 建立规则库与目标库
   规则库与目标库是在程序运行之前，由专家提供，以txt文本方式保存在运行目录下。
   目标库如图所示：
   
   规则库如图所示：
   

2. 建立与显示知识库
   知识库包括规则库中所有的特征信息，建立动态数组feature，逐行逐个读取规则库的特征，判断特征是否已存在数组feature中，若不存在，则将该特征加入动态数组feature中。
   建立Listbox Control用于显示知识库，并对该控件添加变量，变量名为m_feature。

3. 读取已知事实
   创建动态数组message，将用户选择的已知事实放入数组message中。

4. 推理
   用动态数据库message中的事实与目标库animal匹配，若匹配成功，则输出目标，推理成功。取待测试规则与动态数据库进行匹配，若规则的前件全部在动态数据库中，则将该规则加入冲突集，并且标记该规则已测试。若冲突集为空，则推理失败，若冲突集为1，则将该规则加入临时动态数据库，若冲突集大于1，说明产生冲突，选择前件最长的规则加入临时动态数据库。若动态数据库中的特征不在已知事实库中，则加入，否则不加入。

流程图：

算法描述：

1. 将初始事实置入动态数据库；
2. 用动态数据库中的事实，匹配目标条件，若目标条件满足，则推理成功，结束；
3. 用待测试规则集中各规则的前件匹配动态数据库中的事实，将匹配成功的规则组成冲突集；
4. 若冲突集为空，则运行失败，退出；
5. 对冲突集做冲突消解，对选择执行的各规则，将其结论加入动态数据库，或执行其动作，转至2。

源码下载地址：
控制台代码：
https://download.csdn.net/download/weixin_39644536/11422033
MFC代码：
https://download.csdn.net/download/weixin_39644536/11422085