基于规则系统的表示与推理的动物专家系统（使用正向推理和反向推理两种方法）

最新推荐文章于 2022-01-10 21:29:57 发布
最新推荐文章于 2022-01-10 21:29:57 发布
阅读量5.6k 收藏 81
点赞数 9
分类专栏： java 算法 课程作业 文章标签： java 算法 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45289690/article/details/110290029
版权
java 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏
课程作业
4 篇文章 0 订阅
订阅专栏

基于规则系统的表示与推理的动物专家系统（使用正向推理和反向推理两种方法）

文章目录

解题思路

  • 正向推理：
    从用户提供的初始已知事实出发，从规则集中选出一条可适用的规则进行推理，并将推理到的结论加入事实库，重复上述过程，直到求得了所要的解或者规则集无法在扩展为止。算法描述如下：
    （1） DATA<-初始数据库
    （2） Util DATA 满足结束条件以前，do
    （3） Begin
    a) 在规则集中选择一条适用于DATA的规则
    b) 将该规则得到结果加入DATA中
    End
  • 反向推理：
    假设一个目标，通过规则找到推出该目标的证据，若所需的这些证据都在用户给事实库中，就说明假设成立，若无论如何都找不到支持假设的证据，说明原假设不成立，此时需要另做假设。算法描述如下：
    （1）做出假设G
    （2）检查G是否在事实数据库中，若在则假设成功返回该假设匹配成功。若不在，则进行下一步。
    （3）从规则库中寻找能推出该假设的规则。对找到的每一条规则的证据(即规则的左部)分别作为假设递归调用该函数。
    （4）上述调用中若有结果为匹配成功则说明该假设是可以成功推出的，返回匹配成功。
    其实是一个深度搜索的过程

    代码

Inference.java

package com.xiao;

import jdk.nashorn.internal.codegen.ObjectClassGenerator;

import java.awt.*;
import java.util.*;
import java.util.List;


public class Inference {
    //数据库
    String[] FACTS = new String[]{/*1*/"反刍动物",/*2*/"蹄类动物",/*3*/"哺乳动物",
            /*4*/"目视前方",/*5*/"有爪子",/*6*/"有犬齿",/*7*/"吃肉"
            ,/*8*/"下蛋",/* 9*/"会飞",/*10*/"有羽毛",
            /*1l*/"有蹄",/*12*/"肉食动物",/*13*/"鸟类",/*14*/"产奶",/*l5*/"有毛发", /*16*/"善飞",/* 17*/"黑白色",/*18*/"会游泳",
            /*19*/"长腿",/*20*/"长脖子",/*21*/"有黑色条纹",/*22*/"有暗斑点",/*23*/"黄褐色",/*24*/"信天翁",
            /*25*/"企鹅",/*26*/"鸵鸟",/*27*/"斑马",/*28 */"长颈鹿",/* 29 */"老虎",/*30*/"金钱豹"};

    public int[][] RULE_pre = {{15}, {14}, {10}, {9, 8}, {7}, {6, 5, 4}, {3, 2}, {3, 1},
            {23, 22, 12, 3}, {23, 21, 12, 3}, {22, 20, 19, 11},
            {21, 11}, {20, 19, 17, 13, -9}, {18, 17, 13, -9}, {16, 13},
    };

    public int[] RULE_after = {3, 3, 13, 13, 12, 12, 2, 2, 30, 29, 28, 27, 26, 25, 24};
    public HashSet<Integer> curFacts;
    public HashSet<Integer> use_rules;
    public HashSet<Integer> post_use_rules;
    private TextArea t1;
    private TextArea t2;
    private StringBuffer forPanel;
    private StringBuffer process;

    Inference(TextArea t1,TextArea t2) {
        this.t1 = t1;
        this.t2 = t2;
        forPanel = new StringBuffer();
        process = new StringBuffer();
        printFacts_Rules();
        //System.out.println("请输入特征数字以,隔开");
        forPanel.append("请输入特征数字以,隔开\n");
        show();
    }
    public void show(){
        t1.setText(forPanel.toString());
        t2.setText(process.toString());
    }
    public void in(String input){
        String[] sp = input.split(",");
        int[] in = new int[sp.length];
        for(int i = 0;i<in.length;i++)
            in[i] = Integer.parseInt(sp[i]);

        use_rules = new HashSet<>();
        post_use_rules = new HashSet<>();
        curFacts = new HashSet<>();
        for(int i:in){
            curFacts.add(i);
            if(i>0){forPanel.append(FACTS[i-1]+" ");}
            else{forPanel.append("不"+FACTS[Math.abs(i)-1]+" ");}
        }//System.out.print(FACTS[i-1]+" ");}
        forPanel.append("\n");//System.out.println();
        show();
    }
    void printFacts_Rules(){
        for(int i=0;i<FACTS.length;i++){
            if(i%10==0) forPanel.append("\n");//System.out.println();
            forPanel.append((i+1)+" "+FACTS[i]+"  ");//System.out.print(i+1+" "+FACTS[i]+"  ");
        }
        forPanel.append("\n");//System.out.println();

        for(int i=0;i<RULE_pre.length;i++){
            forPanel.append("rule"+(i+1)+": ");//System.out.print("rule"+(i+1)+": ");
            for(int j:RULE_pre[i]){
                if(j>0)
                    forPanel.append(FACTS[Math.abs(j)-1]+" ");//System.out.print(FACTS[Math.abs(j)-1]+" ");
                else
                    forPanel.append("不"+FACTS[Math.abs(j)-1]+" ");
            }
            forPanel.append("----->"+FACTS[RULE_after[i]-1]+"    ");//System.out.print("----->"+FACTS[RULE_after[i]-1]+"    ");
            if(i%3==0) forPanel.append("\n");//System.out.println();
        }
        forPanel.append("\n");//System.out.println();
    }
    private void printCurFacts(){
        process.append("当前事实库");//System.out.print("当前事实库");
        int j = 0;
        for(int i:curFacts){
            if(j%5==0) process.append("\n");//System.out.println();
            j++;
            if(i>0)
            process.append(FACTS[i-1]+ " ");//System.out.print(FACTS[i-1]+ " ");
            else process.append("不"+FACTS[Math.abs(i)-1]+ " ");
        }
        process.append("\n");//System.out.println();
    }

    private void printCurUseRules(){
        for(int i:use_rules){
            if(!post_use_rules.contains(i)){
                process.append("rule"+(i+1)+":");//System.out.print("rule"+(i+1)+":");
                for(int j:RULE_pre[i])
                    if(j>0)
                    process.append(FACTS[Math.abs(j)-1]+" ");//System.out.print(FACTS[Math.abs(j)-1]+" ");
                    else process.append("不"+FACTS[Math.abs(j)-1]+" ");
                process.append("----->"+FACTS[RULE_after[i]-1]+"    ");//System.out.print("----->"+FACTS[RULE_after[i]-1]+"    ");
                post_use_rules.add(i);
            }
        }
        process.append("\n");//System.out.println();
    }
    /**
     * 正向推理
     * */
    public void forword(){
        printCurFacts();
        HashSet<Integer> indexs;
        while (true){
            indexs = find(curFacts);
            printCurUseRules();
            int size = curFacts.size();
            for(int i:indexs)
                curFacts.add(i);

            if(curFacts.size() > size){
                printCurFacts();
                show();
            }
            if(curFacts.size() == size){ break;}
        }
        StringBuffer res = new StringBuffer();
        boolean flags = false;
        process.append("最终结果如下：\n");//System.out.println("最终结果如下：");
        for(int i=24;i<=30;i++){
            if(curFacts.contains(i)){ res.append(FACTS[i-1]+" "); flags=true;}
        }
        if(flags) process.append("推理成功，该可能动物为："+res.toString()+"\n");
        else process.append("推理不成功\n");//System.out.println("推理不成功"); //System.out.println("推理成功，该可能动物为："+res);
        show();
    }
    /**
     * 传入curFacts，返回可推出结论的下标集合
     * curFacts是否包含规则左侧的证据
     * */
    private HashSet<Integer> find(HashSet<Integer> input) {

        HashSet<Integer> res = new HashSet<>();

        HashSet<Integer> hashset = new HashSet<>();
        for(Object i:input.toArray()){
            hashset.add(Integer.parseInt(i.toString()));
        }

        for (int i = 0; i < RULE_pre.length; i++) {
            int j = 0;
            for(j = 0; j < RULE_pre[i].length; j++)
            {
                if(!hashset.contains(RULE_pre[i][j]))
                    break;
            }
            if(j == RULE_pre[i].length){ res.add(RULE_after[i]);use_rules.add(i);}
        }
        return res;
    }
    /**
     * 反向推理
     * */
    public void backword(){
        for(int i=24;i<=30;i++){
            if(dfs(i)){
                process.append("推理成功，该动物可能为："+FACTS[i-1]+"\n");//System.out.println("推理成功，该动物可能为："+FACTS[i-1]);
                break;
            }else{
                process.append("推理不成功，该动物不为："+FACTS[i-1]+"\n");//System.out.println("推理不成功，该动物不为："+FACTS[i-1]);
            }
        }
        show();
    }
    /**
     * 寻找num在规则右部出现的规则
     * */
    private List<Integer> InRULE_after(int num){
        List<Integer> res = new ArrayList<>();
        for(int i=0;i<RULE_after.length;i++){
            if(RULE_after[i] == num)  res.add(i);
        }
        return res;
    }
    /**
     * 深度遍历
     * */
    private boolean dfs(int num){
        String temp = num>0?"":"不";
        process.append("假设为"+temp+FACTS[Math.abs(num)-1]+"\n");

        if(curFacts.contains(num)) return true;
        else{
            List<Integer> indexs = InRULE_after(num);
            if(indexs.size()==0){ return false;}
            else {
                for(int i:indexs){
                    boolean flag = true;
                    for(int j:RULE_pre[i]){
                        String a = j>0?"":"不";
                        if(!dfs(j)){ flag = false; process.append(a+FACTS[Math.abs(j)-1]+ "假设失败\n");}
                        else process.append(a+FACTS[Math.abs(j)-1]+ "假设成功\n");
                    }
                    if(flag){return true;}
                }
                return false;
            }
        }
    }


}

Main.java

package com.xiao;


import javax.swing.*;
import java.awt.Dimension;
import java.awt.TextArea;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class Main extends JFrame {
    private JTextField textField;
    private Inference inference ;
    private TextArea textArea_1;
    private TextArea textArea;
    private JButton button;
    private JButton button_1;
    private boolean isNew = true;
    public Main() {
        setSize(new Dimension(931, 654));
        setResizable(false);
        getContentPane().setLayout(null);

        textArea = new TextArea();
        textArea.setEditable(false);
        textArea.setRows(50);
        textArea.setBounds(50, 29, 830, 204);
        getContentPane().add(textArea);

        textField = new JTextField();
        textField.setBounds(165, 256, 489, 21);
        getContentPane().add(textField);
        textField.setColumns(10);

        button = new JButton("\u6B63\u5411\u63A8\u7406");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if(!isNew) inference = new Inference(textArea,textArea_1);
                String input = textField.getText().toString();
                if(input.equals("")) textArea_1.setText("请输入特征");
                else{ inference.in(input); inference.forword(); isNew=false;}
            }
        });
        button.setBounds(219, 287, 93, 23);
        getContentPane().add(button);

        button_1 = new JButton("\u9006\u5411\u63A8\u7406");
        button_1.setBounds(477, 287, 93, 23);
        button_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if(!isNew) inference = new Inference(textArea,textArea_1);
                String input = textField.getText().toString();
                if(input.equals("")) textArea_1.setText("请输入特征");
                else{ inference.in(input); inference.backword(); isNew=false;}
            }
        });
        getContentPane().add(button_1);

        textArea_1 = new TextArea();
        textArea_1.setRows(50);
        textArea_1.setEditable(false);
        textArea_1.setBounds(50, 334, 820, 280);
        getContentPane().add(textArea_1);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        inference = new Inference(textArea,textArea_1);
    }

    public static void main(String[] args) {
        Main m = new Main();
    }
}

运行结果

输入特征4,5,6,14,22,23 点击正向推理
在这里插入图片描述
输入17,18,10,-9点击逆向推理
在这里插入图片描述
输入1,2,4,5,6
点击正向推理

在这里插入图片描述

点击逆向推理
在这里插入图片描述

看见我请叫我去学习，
关注
  • 9
    点赞
  • 踩
  • 81
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于逻辑规则的图谱推理
DataFun_Hoh的博客
05-02 2696
导读： 近年来，知识图谱在众多行业场景被大量应用，例如推荐、医疗。为了构造尽可能完备的图谱，知识图谱的推理工作也成为学术届和工业界的一个重要研究课题。来自Mila人工智能实验室的瞿锰博士，给大家分享了他们在图谱推理任务方向的一个研究：基于逻辑规则的图谱推理（RNNLogic: Learning Logic Rules for Reasoning on Knowledge Graphs），研究结果显示RNNLogic可以很好地兼顾图谱推理任务的模型效果和可解释性的问题。 本文将围绕以下几点展开： 图谱和..
故障诊断专家系统研究之五-----推理机制及可信度算法
一幅凝固的油画
12-21 7602
 推理机制及可信度算法在第三章和第四章中讨论了如何表示燃气轮机专家的知识以及如何把这些知识存储到知识库之中，即关于知识表示和知识库的问题，而故障诊断专家系统的另一个核心组件就是基于知识的诊断推理机。本章在前两章讨论的知识表示和知识库的基础之上，以正反向相结合的混合推理方式实现诊断推理机，并针对本文提出的知识库模型对混合推理方式的控制策略作了改进，以广度优先索实现正向推理，以深度
专家系统中推理
深未来技术
12-26 2458
一、主要两种方式1、正向链：从事实到结论的推理。如果外面在下雨，你就应带伞。2、反向链：从假设（要证明的结论）到事实的推理。如果外面有人打伞，且鞋子湿了，那么假设外面下雨。二、反射：为避免无谓循环，基于规则的专家系统采用反射，规则在同样的事实一次又一次触发，则专家系统不做任何事。三、推理机重复执行任务的伪码while 还没终止    冲突归结 :如果有激活者，选择最高优
AI 采用C#、基于正向推理机的智能动物识别系统（含源代码及设计文档）
05-27
基于产生式的知识表示方法,采用正向推理,根据特定应用建立好事实库、规则库及推理机后，根据用户输入的动物特征可以判断是何种动物。可以添加新规则、查看规则库，且具有一定的异常检测及控制功能.本系统是采用C#及ASP.NET 2.0编写的多网页WEB系统.采用Visual Studio开发平台和Access数据库。
专家系统中的推理机实现
热门推荐
少安的砖厂
08-08 2万+
专家系统：模仿人类专家的思维方式进行决策的人工智能算法，算法核心是“知识库（knowledge base）”和“推理机（inference engine）”。专家系统通常包括6个部分：人机交互界面、知识库、综合数据库、推理机、解释器、知识获取。 （参考：人工智能-基于规则的专家系统（基础知识）） 知识库：包含解决问题相关的领域知识。在基于规则的专家系统中，知识用一组规则来表达。其具有IF（条件...
动物专家系统C实现【人工智能】建立相应的规则和简易数据库＜正向推理和逆向推理＞
不是一切星星 都仅指示黑暗
01-10 6008
实验内容： 要求: 设计一个动物识别专家系统，规则库至少包含15条规则，可以识别至少7种动物，规则可增加； 界面显示要求: 1）有若干选择动物特征的选择列表； 2）表现判断动物时，使用了哪些规则; 3）表现数据库的变化； 4）显示规则的调用次序； 5）显示最后的结果，包含动物能识别出来和动物不能识别出来两种情况； 6）至少检查两个例子实现正向推理和反向推理的区别  实验思路： （1）、建立知识库利用二维数组features[][11]储存，其中存放的是定义的动物特征， ...
动物识别专家系统，Python+PYNQ，小型产生式系统，正向推理，反向推理
07-03
2、学会编写小型的产生式系统，理解正向推理和反向推理的过程以及两者的区别。 3、学会设计简单的人机交互界面。 内容及步骤（部分） 1.产生式系统简介 规则库：用于描述相应领域内知识的产生式系统。 综合数据库：...
基于C#实现的小型动物识别推理系统.zip
07-04
以动物识别系统为例，用选定的编程语言建造规则库和综合数据库，并能对它们进行增加、删除和修改操作，开发能进行正确的正向推理或反向推理的推理机。 1 熟悉和掌握产生式系统的构成和运行机制； 2 掌握基于规则推理...
动物专家系统MFC界面自带正向推理逆向推理源代码.zip
11-19
本篇将深入探讨一个基于MFC（Microsoft Foundation Classes）界面的动物专家系统，该系统融合了正向推理和逆向推理的技术，旨在为用户提供直观的学习和实践平台。 一、MFC界面设计 MFC是微软提供的一套面向对象的...
动物识别系统 VC++ 逆向搜索 正向搜索
01-01
产生式规则的动物识别系统，人工智能的实验课做了界面，实现了正向搜索和逆向搜索，自认为不错，希望对大家有帮助，
产生式系统-动物识别系统
11-30
还可以，程序简单易懂！程序中特征和动物不要求完全匹配，选择的如果是几个动物相同的特征，这几个动物同时输出！
常见疾病诊断专家系统
10-02
采用VB+数据库编写的常见疾病诊断专家系统，带算法。有完整源代码和文档。
基于C#制作（WinForm）小型动物识别系统进行正向推理【100011021】
02-27
以动物识别系统为例，用选定的编程语言建造规则库和综合数据库，并能对它们进行增加、删除和修改操作，开发能进行正确的正向推理或反向推理的推理机。 1 熟悉和掌握产生式系统的构成和运行机制； 2 掌握基于规则推理...
人工智能-动物识别专家系统.doc
11-24
人工智能-动物识别专家系统是流行的专家系统实验模型，其使用产生式规则来表示知识，共15条规则，可以识别七种动物，这些规则既少又简单，可以改造他们，也可以加进新的规则，还可以用来识别其他东西的新规则来取代...
人工智能公开课——03推理：目标树与基于规则的专家系统
tangering的博客
12-04 1012
课程内容小介绍目标树基于规则的专家系统 小介绍 第一次写博客，目的是将在公开课中所学的东西做一个梳理，同时加深印象。加油！ 目标树 老师首先引入了一个叠方块的程序，即告诉程序需要将哪个方块放到哪个方块上面，程序会通过挪其他方块等一系列操作实现目标，同时该程序还能回答进行某一步移动的原因。 （没学过什么建模语言，就这么凑合看叭） 分解程序：findspace->grasp->move-&...
动物识别系统的规则库
亲爱的老吉先森呀
12-20 5313
一、题目 这是一个用以识别虎、金钱豹、斑马、长颈鹿、企鹅、鸵鸟、信天翁七种动物的产生式系统。为了实现对这些动物的识别，该系统建立了如下规则库： R1： IF 该动物有毛     THEN 该动物是哺乳动物 R2： IF 该动物有奶     THEN 该动物是哺乳动物 R3： IF 该动物有羽毛   THEN 该动物是鸟 R4： IF 该动物会飞     AND 该动物会下蛋   THEN 该动物是鸟 R5： IF 该动物吃肉  
产生式正向推理和逆向推理程序
langwen2048的博客
10-29 1万+
最近人工智能课程结束，本来是考试课，但老师说不用考试，交个设计就行。我就喜欢这样的老师，为我老师点赞，顺便diss一下上课念ppt，停电就没法上课，考试靠死记硬背的某些老师。扯得有点远了，先说说产生式的存储，我是用c#语言中动态数组ArrayList存储的： //规则中的每个子条件及结论都是一个结构体类型： private struct Pre { ...
对规则引擎和专家系统以及rete算法的一点认识
yiguolei的博客
02-18 996
首先，谈一下规则引擎与专家系统的区别，因为网上有很多人将两者混为一谈了，不过这也只是小弟的一点浅显的认识，请各位大侠拍砖啊 规则系统的目的侧重于将业务逻辑的分离，主张业务逻辑从我们的应用编码中解脱出来，便于我们业务逻辑的修改，从而诞生出来的BRMS系统也是用来管理我们的业务规则的。 专家系统：侧重于人工智能，它是基于大量的事实而进行的推理行为，与规则引擎有很大的区别，专家系统注重知识的管理，而...
基于产生式规则的动物识别系统正反向混合推理 python
最新发布
03-25
A：基于产生式规则的动物识别系统是一种基于规则的专家系统，利用已知的规则和先验知识对输入的数据进行处理和识别。本文介绍的动物识别系统是基于产生式规则的，它可以通过一系列的规则来识别输入数据是否属于某种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值