原理及说明

模糊推理所处理的事物自身是模糊的，概念本身没有明确的外延，一个对象是否符合这个概念难以明确地确定模糊推理是对这种不确定性，即模糊性的表示与处理。模糊逻辑推理是基于模糊性知识(模糊规则)的一种近似推理，一般采用Zadeh提出的语言变量、语言值、模糊集和模糊关系合成的方法进行推理。

设计洗衣洗涤时间模糊控制

已知人的操作经验为：
“污泥越多，油脂越多，洗涤时间越长”；
“污泥适中，油脂适中，洗涤时间适中”；
“污泥越少，油脂越少，洗涤时间越短”。

模糊控制规则：
1、if(x is SD)and(y is NG)then(z is VS)(1)
2、if(x is SD)and(y is MG)then(z is M)(1)
3、if(x is SD)and(y is LG)then(z is L)(1)
4、if(x is MD)and(y is NG)then(z is S)(1)
5、if(x is MD)and(y is MG)then(z is M)(1)
6、if(x is MD)and(y is LG)then(z is L)(1)
7、if(x is LD)and(y is MG)then(z is M)(1)
8、if(x is LD)and(y is MG)then(z is L)(1)
9、if(x is LD)and(y is LG)then(z is VL)(1)
其中SD（污泥少）、MD（污泥中）、LD（污泥多）、NG（油脂少）、MG（油脂中）、LG（油脂多）、VS（洗涤时间很短）、S（洗涤时间短）、M（洗涤时间中等）、L（洗涤时间长）、VL（洗涤时间很长）。

题目分析

控制对象是洗衣机的洗涤时间，论域：[0, 60] 。
输入是被洗衣物的污泥和油脂，论域：[0, 100]
1.污泥隶属函数

2.油脂隶属函数

ps：此处函数下标有误，应该是NG,MG,LG（表示自己很懒，所以没改）

3.洗涤时间隶属函数

4.规则表

污泥度\油脂度	NG	MG	LG
SD	VS	M	L
MD	S	M	L
LD	M	L	VL

做题步骤及相应代码

1.定义污泥及油脂隶属函数求对应属性值下的隶属度。
分别定义一个一维三列的数组依次对应少中多。

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

2.规则匹配与激活及规则前件隶属度聚集
将上得到污泥及油脂的隶属度值参考规则表，然后求取最小值。我这里的代码思路是按照规则选择最简单的if条件句，判断得到相应属性值的隶属度。一共会得到1个VS，1个S，3个M，3个L，1个VL的隶属度值。所以需要在得到的M和L的隶属度中先去除0再取最小值。这样就可以得到所有洗涤时间的属性值对应的隶属度了

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]=10-10*a[0]
    time[1]=10*a[1]
    time[2]=25-15*a[1]
    time[3]=15*a[2]+10
    time[4]=40-15*a[2]
    time[5]=15*a[3]+25
    time[6]=60-20*a[3]
    time[7]=20*a[4]+40
    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<=10:
        u1=(10-a)/10
        u2=a/10
        if(u1>u2):
            time_level='VS'
        else:
            time_level='S'
    if 10<a<=25:
        u3=(25-a)/15
        u4=(a-10)/15
        if(u3>u4):
            time_level='S'
        else:
            time_level='M'
    if 25<a<=40:
        u5=(40-a)/15
        u6=(a-25)/15
        if(u5>u6):
            time_level='M'
        else:
            time_level='L'
    if 40<a<=60:
        u7=(60-a)/20
        u8=(a-40)/20
        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)))

运行结果

输入污泥指数:60
输入油脂指数:70
模糊推理系统预测洗涤时间中等,预计洗涤时间31

ps:至此结束，本人写代码不习惯写注释，同样也不喜欢写报告，所以说同仁们看着费解勿怪，在此只希望通过写博客来改变这些习惯，以后一定会越来越认真，努力地去写地详细一点。同时也留点东西，搞得自己像学过一些东西，不是一直在玩，哈哈哈。最后此篇代码纯原创，应该不会触犯到谁，不足也没办法，因为python也没怎么学，代码行里间还是c里c气的。