AI-七种动物识别规则库

AI-动物识别

一、实验目的

1. 理解产生式系统的结构原理与实际应用。 
2. 掌握产生式规则表示及规则库组建的实现方法。 
3. 熟悉和掌握产生式系统的运行机制，掌握基于规则推理的基本方法。

二、实验原理

   产生式系统用来描述若干个不同的以一个基本概念为基础的系统，这个基本概念就是产生式规则或产生式条件和操作对。在产生式系统中，论域的知识分为两部分：用事实表示静态知识；用产生式规则表示推理过程和行为

1.实验要求

运用所学知识，设计并编程一个小型的动物识别系统，识别对象：虎、金钱豹、斑马、长颈鹿、鸵鸟、企鹅、信天翁 七种动物

2.识别规则库

R1:  有毛(1)  --> 哺乳动物(12)  
R2:  有奶(2)  --> 哺乳动物(12)
R3:  有羽毛(3)   --> 鸟类(13)
R4:  会飞(4) & 会下蛋  --> 鸟类(13)
R5:  吃肉(6)  --> 食肉动物(14)
R6:  犬齿(7) & 有爪(8) & 盯前方(9)  --> 食肉动物(14)
R7:  哺乳动物(12) & 有蹄(10)  -->  有蹄类动物(15)
R8:  哺乳动物(12) & 反刍(11)  -->  有蹄类动物(15)
R9:  哺乳动物(12) & 食肉动物(14) & 黄褐色(16) & 暗斑点(17)  --> 金钱豹(a)
R10: 哺乳动物(12) & 食肉动物(14) & 黄褐色(16) & 黑色条纹(18)  --> 虎(b)
R11: 有蹄类动物(15) & 长脖(19) & 长腿(20) & 暗斑色(17)  --> 长颈鹿(c)
R12: 有蹄类动物(15) & 黑色条纹(18) &  -->  斑马(d)
R13: 鸟类(13) & 长脖(19) & 长腿(20) & 不会飞(21) & 黑白两色(22)  -->  鸵鸟(e)
R14: 鸟类(13) & 会游泳(23) & 不会飞(21) & 黑白二色(22)  -->  企鹅(f)
R15: 鸟类(13) & 善飞(24)  -->  信天翁(g)

以上为：动物识别规则的15条规则，已编码

3.思路分析

1. 第一次编写时：采用的是，条件对应原则，每个条件对应的动物做一个集合，多个条件集合取交集，得到对应动物。方法-错误×，未使用该15条规则，推理而得。

   如：当选择 条件不会飞 和 会飞时，集合方式无法推理出结果，
      - 会飞 && 会下蛋  -->  鸟类
      - 鸟类 && 不会飞 && 会游泳 && 黑白二色  --> 企鹅
      + 输入条件：
      - 会飞 && 会下蛋 && 不会飞 && 会游泳 && 黑白二色  -×-> 企鹅
   

2. 改版，版本2.0，重新设计对应方式：

   通过两个数组： 
     - two1 = []    // 存放单击选择的条件
     - three = []   // 初始值为 13个 0 组成的数组
   1. 遍历 选择的条件数组： two1[]  
   
   2. 将拿到的数组结果，依次 if 判断，
      如：
      - 有羽毛(3) 则 将 three 的three[1] = 13 
      - 依次类推
   3. 最后拿到结果：three[] 数组，满足对应条件，而重新赋值的数组，进行判断：
     如：信天翁判断
     -  if ( this.three[1] == 13 && this.three[12] == 24 &&
             this.three[0] == 0 && this.three[2] == 0 && this.three[3] == 0 &&
             this.three[4] == 0 && this.three[5] == 0 && this.three[6] == 0 &&
             this.three[7] == 0 && this.three[8] == 0 && this.three[9] == 0 &&
             this.three[10] == 0 && this.three[11] == 0 )
     - 则为 ：信天翁          
   

三、实验内容

1. 实验要求

1. 实现可以输入任何的事实，并基于原有的规则和输入的事实进行推理

2.遍历-数组规则

1. 由点击传入 two1 数组 的值，为 three数组 赋值

           /*
           遍历所有的规则，得到最好结果
           */
   
           for (let i = 0;i<cond.length;i++){
             // 有毛 || 有奶 ---> 哺乳animal
             if (cond[i] == 1) this.three[0]=12
             if (cond[i] == 2) this.three[0]=12
             // 有羽毛 || （会飞&会下蛋） --->  鸟
             if (cond[i] == 3) this.three[1]=13
   
             if (cond[i] == 4) {
               this.three[1] = 1
               for (let n=0;n<cond.length;n++){
                 if (cond[n] == 5){
                   this.three[1]=13
                 }
               }
             }
             if (cond[i] == 5) {
               this.three[1] = 1
               for (let n=0;n<cond.length;n++){
                 if (cond[n] == 4){
                   this.three[1]=13
                 }
               }
             }
   
             // 吃肉 || （犬齿 & 有爪 & 盯前方） ----> 食肉animal
             if (cond[i] == 6) this.three[2]=14
   
             if (cond[i] == 7) {
               this.three[2] = 4
               for (let n = 0; n < cond.length; n++) {
                 if (cond[n] == 8) {
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 9) {
                       this.three[2] = 14
                       console.log("循环次数：")
                       break
                     }
                   }
                   break
                 }else if (cond[n] == 9){
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 8) {
                       this.three[2] = 14
                       break
                     }
                   }
                   break
                 }
               }
             }
             if (cond[i] == 8) {
               this.three[2] = 4
               for (let n = 0; n < cond.length; n++) {
                 if (cond[n] == 7) {
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 9) {
                       this.three[2] = 14
                       break
                     }
                   }
                   break
                 } else if (cond[n] == 9) {
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 7) {
                       this.three[2] = 14
                       break
                     }
                   }
                   break
                 }
   
               }
             }
   
             if (cond[i] == 9) {
               this.three[2] = 4
               for (let n = 0; n < cond.length; n++) {
                 if (cond[n] == 7) {
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 8) {
                       this.three[2] = 14
                       break
                     }
                   }
                   break
                 } else if (cond[n] == 8) {
                   this.three[2] = 4
                   for (let m = 0; m < cond.length; m++) {
                     if (cond[m] == 7) {
                       this.three[2] = 14
                       break
                     }
                   }
                   break
                 }
   
               }
             }
   
             // （哺乳 & 有蹄）|| （哺乳 & 反刍）  ---> 有蹄类动物
             if (this.three[0] == 12 && cond[i] == 10) this.three[3]=15
             if (this.three[0] == 12 && cond[i] == 11) this.three[3]=15
   
             // 以下是，判断是什么动物
             // 黄褐色
             if (cond[i] == 16) this.three[4]=16
             // 暗斑色
             if (cond[i] == 17) this.three[5]=17
             // 黑色条纹
             if (cond[i] == 18) this.three[6]=18
             // 长脖
             if (cond[i] == 19) this.three[7]=19
             // 长腿
             if (cond[i] == 20) this.three[8]=20
             // 不会飞
             if (cond[i] == 21) this.three[9]=21
             // 黑白两色
             if (cond[i] == 22) this.three[10]=22
             // 会游泳
             if (cond[i] == 23) this.three[11]=23
             // 善飞
             if (cond[i] == 24) this.three[12]=24
           }
   
   

四、实验过程

1.源代码

五、实验结果

1.规则R1:

有毛(1)  --> 哺乳动物(12)

2.规则R2:

 有奶(2)  --> 哺乳动物(12)

3. 规则R3:

R3:  有羽毛(3)   --> 鸟类(13)

4.规则R4：

R4:  会飞(4) & 会下蛋  --> 鸟类(13)

5.规则R5：

R5:  吃肉(6)  --> 食肉动物(14)

6.规则R6：

R6:  犬齿(7) & 有爪(8) & 盯前方(9)  --> 食肉动物(14)

7.规则R7：

R7:  哺乳动物(12) & 有蹄(10)  -->  有蹄类动物(15)

8.规则R8：

R8:  哺乳动物(12) & 反刍(11)  -->  有蹄类动物(15)

9.规则R9:

R9:  哺乳动物(12) & 食肉动物(14) & 黄褐色(16) & 暗斑点(17)  --> 金钱豹(a)

10.规则R10：

R10: 哺乳动物(12) & 食肉动物(14) & 黄褐色(16) & 黑色条纹(18)  --> 虎(b)

11.规则R11：

R11: 有蹄类动物(15) & 长脖(19) & 长腿(20) & 暗斑色(17)  --> 长颈鹿(c)

12.规则R12：

R12: 有蹄类动物(15) & 黑色条纹(18) &  -->  斑马(d)

13.规则R13：

R13: 鸟类(13) & 长脖(19) & 长腿(20) & 不会飞(21) & 黑白两色(22)  -->  鸵鸟(e)

14.规则R14：

R14: 鸟类(13) & 会游泳(23) & 不会飞(21) & 黑白二色(22)  -->  企鹅(f)

15.规则R15：

R15: 鸟类(13) & 善飞(24)  -->  信天翁(g)