付小费的问题

举个小费的例子，如果我们要创建一个控制器来估计我们在餐馆应该给多少小费，我们可以这样构造它:

输入

• 服务
  • 域(即赋值范围):服务员的服务有多好，从1到10分?
  • 模糊集(即模糊值范围):差、可接受、非常好
• 食品质量
  • 域：在1到10的范围内，食物有多美味，从1到10分?
  • 模糊集:差，一般，非常好 ### 输出
• 小费
  • 域:我们应该给多少小费，在0%到25%的范围内
  • 模糊集:低、中、高

规则

• 如果服务好或者食物质量好，那么小费就会很高。
• 如果服务一般，那么小费就是中等。
• 如果服务差，食物质量差，那么小费就会很低。

实例

• 如果我告诉这个控制器我的评级:

  • 服务为9.8
  • 食品质量为6.5

• 它会建议我离开时给20.2%的小费。

付小费的问题-代码实现

注:此方法所有计算都是手工的，一步一步来。 “小费问题”通常用来说明模糊逻辑原理从一组紧凑、直观的专家规则生成复杂行为的能力。

输入变量

在决定就餐时给多少小费时，有很多变量。考虑其中的两个:

• 服务
• 食物质量

输出变量

输出变量只是小费的数量，以百分比表示:

• 小费:帐单的百分之几作为小费

为了便于讨论，我们假设输入变量和输出变量都需要“高”、“中”和“低”隶属度函数。这些在scikit-fuzzy中定义如下

模糊规则

现在，为了使这些三角形有用，我们定义输入变量和输出变量之间的模糊关系。对于我们的例子，考虑三条简单的规则:

• 如果食物很差或者服务很差，那么小费就会很低
• 如果服务可以接受，那么小费将是中等的
• 如果食物很棒或者服务很棒，那么小费就会很高。

大多数人会同意这些规则，但这些规则是模糊的。将不精确的规则映射为定义的、可操作的提示是一项挑战。这是模糊逻辑擅长的一类任务。

规则应用

在以下情况下:

• 服务是9.8
• 食品质量为6.5

规则聚合（Rule aggregation）

已知单个隶属函数之后需要合并它们。这通常使用最大操作符来完成。这一步也被称为聚合。

去模糊化(Defuzzification)

最后,为了得到一个真实的世界答案,我们返回清晰值。我们这个例子中使用质心法。 结果是20.2%的小费。

结语

模糊系统是允许复杂的、直观的行为基于一个开销最小的规则稀疏系统。注意，我们的隶属度函数是粗糙的，仅在整数处定义，但fuzzy .interp_membership允许有效的分辨率随需求而增加。该系统可以对输入的任意小变化作出响应，处理负担最小。

import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt
%matplotlib inline
x = np.arange(11)
mfx = fuzz.trimf(x, [0, 5, 10])

# Generate universe variables
#   * Quality and service on subjective ranges [0, 10]
#   * Tip has a range of [0, 25] in units of percentage points
x_qual = np.arange(0, 11, 1)
x_serv = np.arange(0, 11, 1)
x_tip  = np.arange(0, 26, 1)

# Generate fuzzy membership functions
qual_lo = fuzz.trimf(x_qual, [0, 0, 5])
qual_md = fuzz.trimf(x_qual, [0, 5, 10])
qual_hi = fuzz.trimf(x_qual, [5, 10, 10])

serv_lo = fuzz.trimf(x_serv, [0, 0, 5])
serv_md = fuzz.trimf(x_serv, [0, 5, 10])
serv_hi = fuzz.trimf(x_serv, [5, 10, 10])

tip_lo = fuzz.trimf(x_tip, [0, 0, 13])
tip_md = fuzz.trimf(x_tip, [0, 13, 25])
tip_hi = fuzz.trimf(x_tip, [13, 25, 25])

# Visualize these universes and membership functions
fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(8, 9))

ax0.plot(x_qual, qual_lo, 'b', linewidth=1.5, label='Bad')
ax0.plot(x_qual, qual_md, 'g', linewidth=1.5, label='Decent')
ax0.plot(x_qual, qual_hi, 'r', linewidth=1.5, label='Great')
ax0.set_title('Food quality')
ax0.legend()

ax1.plot(x_serv, serv_lo, 'b', linewidth=1.5, label='Poor')
ax1.plot(x_serv, serv_md, 'g', linewidth=1.5, label='Acceptable')
ax1.plot(x_serv, serv_hi, 'r', linewidth=1.5, label='Amazing')
ax1.set_title('Service quality')
ax1.legend()

ax2.plot(x_tip, tip_lo, 'b', linewidth=1.5, label='Low')
ax2.plot(x_tip, tip_md, 'g', linewidth=1.5, label='Medium')
ax2.plot(x_tip, tip_hi, 'r', linewidth=1.5, label='High')
ax2.set_title('Tip amount')
ax2.legend()

# Turn off top/right axes
for ax in (ax0, ax1, ax2):
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.get_xaxis().tick_bottom()
    ax.get_yaxis().tick_left()

plt.tight_layout()

# We need the activation of our fuzzy membership functions at these values.
# The exact values 6.5 and 9.8 do not exist on our universes...
# This is what fuzz.interp_membership exists for!
qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 6.5)
qual_level_md = fuzz.interp_membership(x_qual, qual_md, 6.5)
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 6.5)

serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 9.8)
serv_level_md = fuzz.interp_membership(x_serv, serv_md, 9.8)
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 9.8)

# Now we take our rules and apply them. Rule 1 concerns bad food OR service.
# The OR operator means we take the maximum of these two.
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)

# Now we apply this by clipping the top off the corresponding output
# membership function with `np.fmin`
tip_activation_lo = np.fmin(active_rule1, tip_lo)  # removed entirely to 0

# For rule 2 we connect acceptable service to medium tipping
tip_activation_md = np.fmin(serv_level_md, tip_md)

# For rule 3 we connect high service OR high food with high tipping
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)
tip0 = np.zeros_like(x_tip)

# Visualize this
fig, ax0 = plt.subplots(figsize=(8, 3))

ax0.fill_between(x_tip, tip0, tip_activation_lo, facecolor='b', alpha=0.7)
ax0.plot(x_tip, tip_lo, 'b', linewidth=0.5, linestyle='--', )
ax0.fill_between(x_tip, tip0, tip_activation_md, facecolor='g', alpha=0.7)
ax0.plot(x_tip, tip_md, 'g', linewidth=0.5, linestyle='--')
ax0.fill_between(x_tip, tip0, tip_activation_hi, facecolor='r', alpha=0.7)
ax0.plot(x_tip, tip_hi, 'r', linewidth=0.5, linestyle='--')
ax0.set_title('Output membership activity')

# Turn off top/right axes
for ax in (ax0,):
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.get_xaxis().tick_bottom()
    ax.get_yaxis().tick_left()

plt.tight_layout()

np.fmin(serv_level_md, tip_md)

array([0.  , 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
       0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
       0.04, 0.04, 0.04, 0.  ])

# Aggregate all three output membership functions together
aggregated = np.fmax(tip_activation_lo,
                     np.fmax(tip_activation_md, tip_activation_hi))

# Calculate defuzzified result
tip = fuzz.defuzz(x_tip, aggregated, 'centroid')
tip_activation = fuzz.interp_membership(x_tip, aggregated, tip)  # for plot

# Visualize this
fig, ax0 = plt.subplots(figsize=(8, 3))

ax0.plot(x_tip, tip_lo, 'b', linewidth=0.5, linestyle='--', )
ax0.plot(x_tip, tip_md, 'g', linewidth=0.5, linestyle='--')
ax0.plot(x_tip, tip_hi, 'r', linewidth=0.5, linestyle='--')
ax0.fill_between(x_tip, tip0, aggregated, facecolor='Orange', alpha=0.7)
ax0.plot([tip, tip], [0, tip_activation], 'k', linewidth=1.5, alpha=0.9)
ax0.set_title('Aggregated membership and result (line)')

# Turn off top/right axes
for ax in (ax0,):
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.get_xaxis().tick_bottom()
    ax.get_yaxis().tick_left()
plt.tight_layout()