0
0

人工智能原理实验3——产生式推理系统

🧡🧡实验内容🧡🧡

以动物识别系统为例，用选定的编程语言建造规则库和综合数据库，开发能进行正确的正向推理或反向推理的推理机。
正向推理过程
从已知事实出发，通过规则库求得结论，或称数据驱动方式。推理过程是：
1.规则集中的规则前件与事实库中的事实进行匹配，得匹配的规则集合。
2.从匹配规则集合中选择一条规则作为使用规则。
3.执行使用规则的后件，将该使用规则的后件送入事实库中。
4.重复这个过程直至达到目标。

规则集
（1）若某动物有奶，则它是哺乳动物。
（2）若某动物有毛发，则它是哺乳动物。
（3）若某动物有羽毛，则它是鸟。
（4）若某动物会飞且生蛋，则它是鸟。
（5）若某动物是哺乳动物且有爪且有犬齿且目盯前方，则它是食肉动物。
（6）若某动物是哺乳动物且吃肉，则它是食肉动物。
（7）若某动物是哺乳动物且有蹄，则它是有蹄动物。
（8）若某动物是有蹄动物且反刍食物，则它是偶蹄动物。
（9）若某动物是食肉动物且黄褐色且有黑色条纹，则它是老虎。
（10）若某动物是食肉动物且黄褐色且有黑色斑点，则它是金钱豹。
（11）若某动物是有蹄动物且长腿且长脖子且黄褐色且有暗斑点，则它是长颈鹿。
（12）若某动物是有蹄动物且白色且有黑色条纹，则它是斑马。
（13）若某动物是鸟且不会飞且长腿且长脖子且黑白色，则它是驼鸟。
（14）若某动物是鸟且不会飞且会游泳且黑白色，则它是企鹅。
（15）若某动物是鸟且善飞且不怕风浪，则它是海燕。

🧡🧡实现🧡🧡

数据结构

  1. def__init__(self):
  2.         self.rule_dict ={}# 规则：key为条件，value为结论
  3.         self.fact_list =[]# 事实
  4.         self.process =""# 推导过程
  5.         self.conclusion =""# 结论
  6.         self.data_base =set()# 数据库
  • 规则的存储：用字典存储，规则的条件作为key值，规则的结论作为value值，例如，对于规则“若某动物有奶，则它是哺乳动物”和“若某动物会飞且生蛋，则它是鸟”，则它们的存储的字典为： { （“有奶”）：哺乳动物， （“会飞”，“生蛋”）：鸟 }
  • 事实的存储：列表存储，元素为字符串，例如对于事实F1：某动物有毛发、F2：吃肉、F3：黄褐色、F4：有黑色条纹，则存储为 [ “有毛发”，“吃肉”，“黄褐色”，“黑色条纹”]
  • 推导过程和结论的存储：均用字符串。
  • 数据集的存储：存储推导过程中的已知的条件和已经推导出的结论，用集合存储，防止重复添加。

核心算法

  1.         self.fact_list =[fact.strip()for fact in fact_content_list] 
  2.         self.data_base =set(self.fact_list)# 将事实存入数据库
  3.         self.process=""
  4.         flag =False# 是否能推导成功
  5.         n =0while n <2:# 循环两遍for premise, conclusion in self.rule_dict.items():
  6.                 premise=set(premise)# tuple 转 setif premise <= self.data_base:# 集合运算<=  前提是否都在data_base中if conclusion in self.data_base:continue
  7.                     self.data_base.add(conclusion)
  8.                     self.conclusion = conclusion
  9.                     self.process +="%s -----> %s\n"%(premise, conclusion)
  10.                     flag =True
  11.             n +=1

1.获取用户输入的事实（facts）。
2.将事实存入数据库（data_base）。
3.遍历规则字典（rule_dict），判断每条规则的前提条件是否在数据库中。
4.如果前提条件满足，将规则的结论加入数据库，并记录推导过程。
5.重复步骤3和4，直到没有新的结论被加入数据库（达到一定的循环次数）。

为什么要外套一层循环while？
保证推导的准确性和完整性。
例如，有规则R1、R2、R3如下：
R1：若某动物是哺乳动物且吃肉，则它是食肉动物。
R2：若某动物有毛发，则它是哺乳动物。
R3：若某动物是食肉动物且黄褐色且有黑色条纹，则它是老虎。
有事实如下：
F1：某动物有毛发
F2：吃肉
F3：黄褐色
F4：有黑色条纹
如果只遍历一轮：
对于R1：数据集中现有知识不满足前提条件“哺乳动物”。
对于R2：满足“有毛发”前提条件，将其结论“哺乳动物”加入数据集中
对于R3：数据集中现有知识不满足前提条件“食肉动物”
显然，由于遍历有先后顺序，导致后续的规则可能因为前提条件未满足而无法推导出结论，因此需要多套一层循环，再遍历一轮即可。

结果展示

输入格式说明：
我指定了输入规则的具体格式，以便程序容易识别规则的前提条件和结论。
如下图：=>前面的是条件，且用，分隔开，=>后面的是结论
在这里插入图片描述

利用python的tkinter库实现了简单的界面交互，这是初始界面
在这里插入图片描述

为方便后续增删改查的操作，这里设置了文本框不能输入的状态，只作为展示框，因此需要通过读入文件的形式展示规则。
在这里插入图片描述

在粉色框中，可以实现增删改的操作，例如，添加一条规则：“如果某动物能爬树，且有超高智商，则它是猴子”。同时，添加前会对规则库进行查询，若规则库已有知识，则会提示不能添加。删除同理。如果想进行修改操作，可以进行先删除后添加的操作。
在这里插入图片描述
在这里插入图片描述

输入事实，点击按钮进行分析
在这里插入图片描述
在这里插入图片描述

🧡🧡完整代码🧡🧡

需要安装tkinter库 ~

  1. import re
  2. import tkinter as tk
  3. from tkinter import ttk, filedialog, font
  4. import tkinter.messagebox
  6. classAnimalReasoningSystem:def__init__(self):
  7.         self.rule_dict ={}# 规则：key为条件，value为结论
  8.         self.fact_list =[]# 事实
  9.         self.process =""# 推导过程
  10.         self.conclusion =""# 结论
  11.         self.data_base =set()# 数据库# region =======================渲染======================
  12.         self.root_win = tk.Tk()
  13.         self.root_win.title("动物推理系统")
  14.         self.root_win.geometry("950x600+250+100")
  15.         self.root_win.config(bg="DeepSkyBlue4")
  16.         button_style ={'bg':'#666699','fg':'#FFFFCC','activebackground':'#FFF5EE','activeforeground':'#2F4F4F','relief':'raised','anchor':'center','font': font.Font(size=12,weight="bold")}
  17.         label_font=font.Font(family="黑体", size=15, weight="bold")# =========左右布局框==========
  18.         self.left_frame = tk.Frame(self.root_win, width=550, bg="lightblue")
  19.         self.left_frame.pack(side="left", fill="y", pady=20, padx=20, ipady=10, ipadx=10)
  20.         self.right_frame = tk.Frame(self.root_win,
  21.                                     border=2,
  22.                                     bg="#99CCCC")
  23.         self.right_frame.pack(fill="both",
  24.                               pady=20, ipady=30, padx=20, ipadx=30,
  25.                               expand=True)# ========左框组件===========
  26.         self.text_label = tk.Label(self.left_frame, text="规则",font=label_font)
  27.         self.text_label.pack(pady=10)
  28.         self.input_button = tk.Button(self.left_frame,
  29.                                       text="读入文件",
  30.                                       command=lambda: self.open_txt_file(),**button_style)
  31.         self.input_button.pack(pady=5)
  32.         self.input_text_frame = tk.Frame(self.left_frame,bg="lightblue")
  33.         self.input_text_frame.pack()
  34.         self.input_scrollbar = tk.Scrollbar(self.input_text_frame,
  35.                                        orient="vertical",
  36.                                        highlightbackground="blue",)
  37.         self.input_scrollbar.pack(side="right", fill="y")
  38.         self.input_text = tk.Text(self.input_text_frame,
  39.                                   width=60,
  40.                                   height=30,
  41.                                   bg="lightblue",
  42.                                   yscrollcommand=self.input_scrollbar.set)
  43.         self.input_scrollbar.configure(command=self.input_text.yview)
  44.         self.input_text.pack(pady=5)
  45.         self.input_text.config(state="disabled")
  47.         self.func_frame = tk.Frame(self.left_frame, bg="lightblue")
  48.         self.func_frame.pack()
  50.         self.add_btn = tk.Button(self.func_frame, text="添加",
  51.                                  command=lambda: self.add_rule(),**button_style)
  52.         self.del_btn = tk.Button(self.func_frame, text="删除",
  53.                                  command=lambda: self.del_rule(),**button_style)
  54.         self.add_btn.grid(row=0, column=0, padx=10)
  55.         self.del_btn.grid(row=0, column=1, padx=10)
  56.         self.func_text=tk.Text(self.left_frame,bg="pink",width=60)
  57.         self.func_text.pack(pady=7)# ========右框组件===========
  58.         self.right_top = tk.Frame(self.right_frame, width=400, height=150, bg="#99CCCC")
  59.         self.right_top.pack(padx=10, pady=10)
  60.         self.right_middle = tk.Frame(self.right_frame, width=400, height=300, bg="#99CCCC")
  61.         self.right_middle.pack(padx=10, pady=20)
  62.         self.right_bottom = tk.Frame(self.right_frame, width=400, height=50, bg="#99CCCC")
  63.         self.right_bottom.pack(padx=10, pady=20)
  65.         self.top_label = tk.Label(self.right_top, text="事实",font=label_font)
  66.         self.top_label.pack()
  67.         self.top_text = tk.Text(self.right_top, height=8, width=60,bg="#FFFFCC")
  68.         self.top_text.pack(padx=5)
  69.         self.analyse_button = tk.Button(self.right_top,
  70.                                         text="分析",
  71.                                         command=lambda: self.analyse(),**button_style)
  72.         self.analyse_button.pack(padx=10)
  74.         self.middle_label = tk.Label(self.right_middle, text="推导过程",font=label_font)
  75.         self.middle_label.pack()
  76.         self.middle_text = tk.Text(self.right_middle, height=16, width=60,bg="#FFFFCC")
  77.         self.middle_text.pack(padx=5)
  79.         self.bottom_label = tk.Label(self.right_bottom, text="结论",font=label_font)
  80.         self.bottom_label.pack()
  81.         self.bottom_text = tk.Text(self.right_bottom, height=5, width=30,bg="#FFFFCC")
  82.         self.bottom_text.pack(padx=5)# ==========保持主循环===========
  83.         self.root_win.mainloop()# endregiondefshow_rule(self):# 展示规则
  84.         self.input_text.config(state="normal")
  85.         text_content=""for premises,conclusion in self.rule_dict.items():for idx,p inenumerate(premises):
  86.                 text_content+=p
  87.                 if idx==len(premises)-1:continue
  88.                 text_content+="，"
  89.             text_content +="=>"+conclusion+"\n"
  90.         self.input_text.delete(1.0, tk.END)
  91.         self.input_text.insert(tk.END,text_content)
  92.         self.input_text.config(state="disabled")#defopen_txt_file(self):# 使用文件对话框选择要打开的文件
  93.         filepath = filedialog.askopenfilename(filetypes=[('Text Files','*.txt')])if filepath:# 读取文件内容withopen(filepath,'r', encoding='utf-8')asfile:
  94.                 txt_content =file.read()# 存入rule_dict中
  95.             txt_content = txt_content.split("\n")# print(txt_content)for line in txt_content:
  96.                 line = line.strip()ifnot line:# 忽略空行continueif"=>"notin line:# 如果该行不包含"=>"print(f"error: {line}")
  97.                     tkinter.messagebox.showerror("错误","规则格式错误！")return
  99.                 premise, conclusion = line.split("=>")# 解析条件和结论
  100.                 premise =[p.strip()for p in premise.split("，")]# 将条件用逗号分隔成列表
  101.                 conclusion = conclusion.strip()
  103.                 self.rule_dict[tuple(premise)]= conclusion
  104.             # print(self.rule_dict)
  105.             self.show_rule()defanalyse(self):# 根据事实和规则进行推导
  106.         fact_content = self.top_text.get("1.0", tk.END)
  107.         fact_content_list = fact_content.split("\n")
  108.         fact_content_list.pop()# 去除\n分割出的最后一行空白“”
  109.         self.fact_list =[fact.strip()for fact in fact_content_list]# 去除每行的前后空格# print(self.fact_list)
  111.         self.data_base =set(self.fact_list)# 将事实存入数据库
  112.         self.process=""
  113.         flag =False# 是否能推导成功
  114.         n =0while n <2:# 循环两遍for premise, conclusion in self.rule_dict.items():
  115.                 premise=set(premise)# tuple 转 setif premise <= self.data_base:# 集合运算<=  前提是否都在data_base中if conclusion in self.data_base:continue
  116.                     self.data_base.add(conclusion)
  117.                     self.conclusion = conclusion
  118.                     self.process +="%s -----> %s\n"%(premise, conclusion)
  119.                     flag =True
  120.             n +=1if flag:
  121.             self.middle_text.delete("1.0", tk.END)# 清空
  122.             self.bottom_text.delete("1.0", tk.END)
  123.             self.middle_text.insert(tk.END, self.process)# 添加
  124.             self.bottom_text.insert(tk.END, self.conclusion)else:
  125.             tkinter.messagebox.showerror("错误","推导失败！请再完善规则或检查事实！")deffind_rule(self, premise_list):# 查找规则
  126.         flag =Falsefor premises in self.rule_dict.keys():iftuple(premise_list)== premises:
  127.                 flag =Truebreakreturn flag
  129.     defadd_rule(self):# 添加规则
  130.         text_content=self.func_text.get("1.0",tk.END)# str
  131.         text_content.strip()print(text_content)if"=>"notin text_content:return
  132.         premise, conclusion = text_content.split("=>")# 解析条件和结论
  133.         premise_list =[p.strip()for p in premise.split("，")]# 将条件用逗号分隔成列表ifnot self.find_rule(premise_list):
  134.             self.rule_dict[tuple(premise_list)]=conclusion
  135.             self.show_rule()
  136.             tk.messagebox.showinfo("提示","添加成功！")else:
  137.             tk.messagebox.showerror("错误","规则已经存在！请勿重复添加！")defdel_rule(self):# 删除规则
  138.         text_content=self.func_text.get("1.0",tk.END)# str
  139.         text_content.strip()if"=>"notin text_content:return
  140.         premise, conclusion = text_content.split("=>")# 解析条件和结论
  141.         premise_list =[p.strip()for p in premise.split("，")]# 将条件用逗号分隔成列表if self.find_rule(premise_list):del self.rule_dict[tuple(premise_list)]
  142.             self.show_rule()
  143.             tk.messagebox.showinfo("提示","删除成功！")else:
  144.             tk.messagebox.showerror("错误","要删除的规则不存在！")if __name__ =='__main__':
  145.     AnimalReasoningSystem()

🧡🧡总结🧡🧡

心得体会
从知识的理论层面：这个产生式推导实验主要模拟了正向推理，熟悉和掌握了产生式系统的运行机制，掌握了基于规则推理的基本方法，实现了动物分类系统，更加了解了人工智能领域的知识表示和推理方法。
从实践代码的角度：实验本身的正向推理的实现逻辑并不复杂，但是关键是要选好合适的数据结构，以及合适的语言实现，对于这个实验，python的便捷性就显现出来了，一来python有强大的数据处理能力，如列表、字典、集合等数据结构，以及灵活的迭代器，使得我可以方便的存储和操作大量的规则和事实，并进行高效的规则查询和推理。此外，我再次练习了tkiner GUI库的组件方法，增强了代码的交互性，方便规则的增上改查。

标签： 人工智能 产生式系统 python
本文转载自: https://blog.csdn.net/luohaojia123/article/details/135738259
版权归原作者 在半岛铁盒里 所有， 如有侵权，请联系我们删除。
登录后发布评论

“人工智能原理实验3——产生式推理系统”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。