【人工智能】模糊逻辑推理-洗衣机模糊推理系统

一、实验目的

理解模糊逻辑推理的原理及特点,熟练应用模糊推理,并以此设计一个洗衣机模糊推理系统。

二、实验原理

模糊推理即以模糊集合论为基础描述工具,对以一般集合论为基础描述工具的数理逻辑进行扩展,从而建立了模糊推理理论。是不确定推理的一种。在人工智能技术开发中有重大意义。

整个模糊推理的过程就是由一组模糊规则出发。许多模糊规则实际上是一组多重条件语句,可以表示为从条件论域到结论论域的模糊关系矩阵R。通过条件模糊向量与模糊关系R的合成进行模糊推理,得到结论的模糊向量,然后采用"清晰化"方法将模糊结论转换为精确量。

三、实验过程记录

已知人的操作经验为:

"污泥越多,油脂越多,洗涤时间越长";

"污泥适中,油脂适中,洗涤时间适中";

"污泥越少,油脂越少,洗涤时间越短"

可以得到以下模糊控制规则表

|-------|-------|--------|
| x | y | z |
| SD | NG | VS |
| SD | MG | M |
| SD | LG | L |
| MD | NG | S |
| MD | MG | M |
| MD | LG | L |
| LD | NG | M |
| LD | MG | L |
| LD | LG | VL |

其中SD(污泥少)、MD(污泥中)、LD(污泥多)、NG(油脂少)、MG(油脂中)、LG(油脂多)、VS(洗涤时间很短)、S(洗涤时间短)、M(洗涤时间中等)、L(洗涤时间长)、VL(洗涤时间很长)。

假设污泥、油脂、洗涤时间的论域分别为[0,100]、[0,100]、[0,120],设计模糊推理系统如下:

输入:待洗涤衣物的污泥和油脂

控制对象:洗涤时间

污泥隶属函数:

油脂隶属函数:

时间隶属函数:

Python代码实现:

python 复制代码
def Sludge(a):#污泥

    sludge=[0,0,0]#默认隶属度为0,依次对应SD,MD,LD

    if a<0 or a>100:

        return (print("输入值有误"))

    elif 0<=a<=50:

        sludge[0]=(50-a)/50

        sludge[1]=a/50

    elif 50<a<=100:

        sludge[1]=(100-a)/50

        sludge[2]=(a-50)/50

    return sludge



def Grease(a):#油脂

    grease=[0,0,0]#默认隶属度为0,依次对应NG,MG,LG

    if a<0 or a>100:

        return (print("输入值有误"))

    elif 0<=a<=50:

        grease[0]=(50-a)/50

        grease[1]=a/50

    elif 50<a<=100:

        grease[1]=(100-a)/50

        grease[2]=(a-50)/50

    return grease



def Rules(a,b):#a为污泥隶属度,b为油脂隶属度

    rules_value=[0,0,0,0,0,0,0,0,0]#依次对应9条规则结果VS,M,L,S,M,L,M,L,VL

    if a[0]!=0 and b[0]!=0:

        rules_value[0]=min(a[0],b[0])#返回规则下最小值

    if a[0]!=0 and b[1]!=0:

        rules_value[1]=min(a[0],b[1])

    if a[0]!=0 and b[2]!=0:

        rules_value[2]=min(a[0],b[2])

    if a[1]!=0 and b[0]!=0:

        rules_value[3]=min(a[1],b[0])

    if a[1]!=0 and b[1]!=0:

        rules_value[4]=min(a[1],b[1])

    if a[1]!=0 and b[2]!=0:

        rules_value[5]=min(a[1],b[2])

    if a[2]!=0 and b[0]!=0:

        rules_value[6]=min(a[2],b[0])

    if a[2]!=0 and b[1]!=0:

        rules_value[7]=min(a[2],b[1])

    if a[2]!=0 and b[2]!=0:

        rules_value[8]=min(a[2],b[2])

    return rules_value



#每条规则推理输出

def Inference(a):#a为9条规则下的结果隶属度

    time_level=[0,0,0,0,0]#默认时间隶属值为0,依次对应VS,S,M,L,VL

    time_level[0]=a[0]

    time_level[1]=a[3]

    if(a[1]!=0 or a[4]!=0 or a[6]!= 0):#去零值然后取剩下的最小值

        list_1=[a[1],a[4],a[6]]

        for i in range(len(list_1)-1,-1,-1):

            if list_1[i]==0:

                list_1.remove(0)

        time_level[2]=min(list_1)

    if(a[2]!=0 or a[5]!=0 or a[7]!= 0):

        list_2=[a[2],a[5],a[7]]

        for i in range(len(list_2)-1,-1,-1):

            if list_2[i]==0:

                list_2.remove(0)

        time_level[3]=min(list_2)

    time_level[4]=a[8]

    return time_level



def Area_gravity(a):#a为时间隶属度

    time=[0,0,0,0,0,0,0,0]#时间隶属函数八个区间分别对应的时间值

    time[0]=20-20*a[0]

    time[1]=20*a[1]

    time[2]=50-30*a[1]

    time[3]=30*a[2]+20

    time[4]=80-30*a[2]

    time[5]=30*a[3]+50

    time[6]=120-40*a[3]

    time[7]=40*a[4]+80

    sum_1=time[0]*a[0]+time[1]*a[1]+time[2]*a[1]+time[3]*a[2]+time[4]*a[2]+time[5]*a[3]+time[6]*a[3]+time[7]*a[4]

    sum_2=a[0]+2*a[1]+2*a[2]+2*a[3]+a[4]

    result=sum_1/sum_2

    return result#最后返回预测时间



def Maximum(a):#a为时间值

    if 0<=a<=20:

        u1=(20-a)/20

        u2=a/20

        if(u1>u2):

            time_level='VS'

        else:

            time_level='S'

    if 20<a<=50:

        u3=(50-a)/30

        u4=(a-20)/30

        if(u3>u4):

            time_level='S'

        else:

            time_level='M'

    if 50<a<=80:

        u5=(80-a)/30

        u6=(a-50)/30

        if(u5>u6):

            time_level='M'

        else:

            time_level='L'

    if 80<a<=120:

        u7=(120-a)/40

        u8=(a-80)/40

        if(u7>u8):

            time_level='L'

        else:

            time_level='VL'

    return time_level



if __name__ == '__main__':

    sludge =int(input("输入污泥值:"))

    grease =int(input("输入油脂值:"))

    rules_value=Rules(Sludge(sludge),Grease(grease))

    time_level=Inference(rules_value)#时间隶属度

    result_1=Area_gravity(time_level)#面积重心法求得的预测时间

    result_2=Maximum(result_1)#最大隶属度法求得的预测时间长短

    result_3={'VS':'很短','S':'短','M':'中等','L':'长','VL':'很长'}

    print("预测洗涤时间属于 {},预计洗涤时间{}".format(result_3[result_2],int(result_1+0.5)))

四、实验结果

假设当前传感器测得的信息为污泥x=60,油脂y=70,采用模糊决策,给出结果。

运行Python程序,输入污泥值值和油脂值,结果如下:

五、实验过程中存在的问题及解决方案

最开始进行实验时,对课本上的数学推理过程不能很好的理解,导致变成速度比较慢。后期通过参考网上类似的代码和分析,逐渐明白了模糊逻辑推理的原理和具体Python实现方法,最终完成了实验。

六、实验总结

在本次实验中,设计了一个洗衣机模糊推理系统,同时通过Python进行了具体的代码实现及应用。通过这次实验,我进一步理解了模糊逻辑推理的原理及特点,同时可以应用模糊推理理论到实际情境中来。

目前,在人工智能领域的自动控制、模式识别、自然语言理解、机器人及专家系统研制等方面,模糊推理的应用取得了一定的成果。并且,在知识表示方面,模糊逻辑有着相当广阔的应用前景。

相关推荐
带娃的IT创业者11 分钟前
机器学习实战(8):降维技术——主成分分析(PCA)
人工智能·机器学习·分类·聚类
鸡鸭扣33 分钟前
Docker:3、在VSCode上安装并运行python程序或JavaScript程序
运维·vscode·python·docker·容器·js
调皮的芋头35 分钟前
iOS各个证书生成细节
人工智能·ios·app·aigc
paterWang1 小时前
基于 Python 和 OpenCV 的酒店客房入侵检测系统设计与实现
开发语言·python·opencv
东方佑1 小时前
使用Python和OpenCV实现图像像素压缩与解压
开发语言·python·opencv
神秘_博士2 小时前
自制AirTag,支持安卓/鸿蒙/PC/Home Assistant,无需拥有iPhone
arm开发·python·物联网·flutter·docker·gitee
flying robot3 小时前
人工智能基础之数学基础:01高等数学基础
人工智能·机器学习
Moutai码农3 小时前
机器学习-生命周期
人工智能·python·机器学习·数据挖掘
188_djh3 小时前
# 10分钟了解DeepSeek,保姆级部署DeepSeek到WPS,实现AI赋能
人工智能·大语言模型·wps·ai技术·ai应用·deepseek·ai知识
Jackilina_Stone3 小时前
【DL】浅谈深度学习中的知识蒸馏 | 输出层知识蒸馏
人工智能·深度学习·机器学习·蒸馏