Python小实验——洗衣机模糊推理_假设污泥油脂洗涤时间的论域

一、实验目的

已知有模糊规则:“如果污泥多，油脂多，则洗涤时间长”。设:
污泥论域:{少，中等，多};“污泥多”=0/少+0.5/中等+1/多;油脂论域:{无，中等,多}﹔“油脂多”=0/少+0.5/中等+1/多;洗涤时间论域:{很短,短，长,很长};
“洗涤时间长”=0/很短+0.3/短+0.6/长+1.0/很长

内容:输入是被洗衣物的污泥和油脂的模糊量，计算洗涤时间。例如已知事实:“污泥多”=0.3/少+0.6/中等+0.8/多;
“油脂多”=0.8/少+0.3/中等+0.2/多。
要求:
1.打印模糊关系R（污泥到洗涤时间R1,油脂到洗涤时间R2,两者到洗涤时间关系R）;
⒉打印模糊向量;
3.输出最终决策，即洗涤时间。

二、实验内容

import numpy as np

# 定义模糊集合
def washingMap():
    mud = np.asarray([0,0.5,1])
    oil = np.asarray([0,0.5,1])
    time = np.asarray([0,0.3,0.6,1]).reshape(1, 4)
    map = {'mud':mud,'oil':oil,'time':time}
    return map

# 获取模糊量
def insertValue():
    print("污渍模糊量：")
    arr = input('')
    mud = np.asarray([float(n) for n in arr.split(' ')])
    print("油脂模糊量：")
    arr = input('')
    oil = np.asarray([float(n) for n in arr.split(' ')])
    fuzzyArray = {'mud':mud,'oil':oil}
    return fuzzyArray

# 洗涤时间论域
def washingTime(x):
    time = {1:'很短',2:'短',3:'长',4:'很长'}
    return time.get(x+1)

# 最终决策
def result(x):
    rs = []
    for i in range(len(x)):
        rs.append(washingTime(x[i]))
    return rs

# 计算模糊关系
def fuzzy(a1,a2):
    r = np.zeros(shape=(len(a1),len(a2)), dtype=float)
    for i in range(len(a1)):
        for j in range(len(a2)):
            r[i][j]=min(a1[i],a2[j])
    return r

# 最大代数合成法
def maximum(a1,a2):
    r = np.zeros(shape=(len(a1)),dtype=float)
    for i in range(len(a1)):
        r[i]=a1[i]*a2[i] #最大代数合成法
        # r[i]=min(a1[i],a2[i]) #最大最小合成法
    return max(r)

# 模糊关系的合成:最大代数积合成法
def fuzzySynthesis(a1,a2):
    r = np.zeros((a1.shape[0],a2.shape[1]), dtype=float)
    for i in range(a1.shape[0]):
        for j in range(a2.shape[1]):
            r[i][j]=maximum(a1[i],a2[:,j:j+1].flatten())
    return r

# 获取输入，获取模糊数组
fuzzyArray = insertValue()
washingArray = washingMap()

# 打印模糊关系R
print()
print("模糊关系R")
a1 = fuzzy(washingArray.get('mud'),washingArray.get('oil'))
R = fuzzySynthesis(a1.flatten().reshape(9,1),washingMap().get('time'))
print(R)

# 打印模糊向量
print()
print()
print("模糊向量")
a2 = fuzzy(fuzzyArray.get('mud'),fuzzyArray.get('oil'))
S = fuzzySynthesis(a2.flatten().reshape(1,9),R)
print(S)

# 推理结果
print()
print()
print("最终决策，最大隶属度法：")
x = []
max = S.max()
a = S.flatten()
for i in range(len(a)):
    if a[i]==max:
     x.append(i)
print(f"由模糊向量可知，洗涤时间{result(x)}的隶属度最大{max}，所以洗涤时间为{result(x)}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

三、实验结果

最大代数积合成法

最大最小合成法