模糊综合评判Python实现：隶属函数、权重与合成算子全链路

简介：面向高校学生、课程设计者与工程技术人员，这份资源聚焦模糊综合评判方法及其 Python 实现，适合希望把因素集、评价集、权重、隶属度向量与模糊评判矩阵等概念落到代码中的读者。压缩包共 3 个文件，包含 1 份 PDF、1 份 Python 脚本和 1 份 DOC 文档，整体约 250KB，分别可用于理论梳理、代码参考与实现说明。目前已有 3621 人学习下载，反映出模糊评价在课程设计、项目评审与算法实践中具有稳定关注度。读者可据此理解合成算子的选取思路，参考 Python 脚本完成权重计算、模糊矩阵构建、模糊乘法运算与结果归一化，并借助文档理清从指标定义、权重确定到综合评价输出的完整流程，为后续调整评价标准、引入更多指标或扩展模糊逻辑模型提供可复用的实现基础，也可用于课程作业与小型项目原型验证。

1. 从一张评分表到一句结论：模糊综合评判 Python 实现解决的是什么问题

一张评价表拍过来：十几项指标，每项都打了分，要的是一句“这个对象属于优、良、中、差哪一档”。加权平均能算出总分，但它回答不了“某项指标刚好卡在两档中间”这种模糊地带。模糊综合评判 python 这套脚本处理的就是这件事——把指标实测值经隶属函数转成隶属度矩阵 R，配上权重向量 A，用模糊合成算子得到对各评语等级的隶属程度向量 B，再按最大隶属度原则定级，或者用等级分数向量还原成百分制得分。

它适合手里已经有一张指标体系表、指标值能拿到、想先把评价流程完整跑通再慢慢调参的人；也适合内部评审模型的前期原型验证。想要接实时数据、对外提供接口的，这套脚本只能算计算内核的基础，外面还得自己包一层。

2. 包结构与技术栈：一个 zip 里的模块分工和数据契约

拿到压缩包先别急着运行main.py。这类评价脚本最容易出问题的环节是数据入口，算法本身反而不常出错——指标顺序错一列、评语等级少一档，跑出来的结论会完全相反，而且不报错。所以先看结构，再看数据长什么样。

2.1 目录树与各模块职责

一套写得比较规整的模糊综合评判工程，常见做法是按“数学原语 → 组合逻辑 → 业务流程”三层切分，而不是把所有函数塞进一个文件里：

fuzzy_eval/ ├── main.py # 命令行入口：读配置、读数据、跑流程、写结果 ├── config.yaml # 评语集、等级分数、算子类型、权重方法 ├── fuzzy/ │ ├── __init__.py │ ├── membership.py # 隶属函数库：三角/梯形/正态/降半梯形 │ ├── weight.py # 权重：AHP、熵权法、变异系数、组合权重 │ ├── operator.py # 四种模糊合成算子 │ └── evaluate.py # 一级/多级综合评判主流程 ├── utils/ │ ├── io_utils.py # Excel 读写、字段校验 │ └── plot_utils.py # 隶属度热力图、评判向量柱状图 ├── data/ │ ├── indicators.xlsx # 指标实测值 │ └── ahp_matrix.xlsx # 判断矩阵（用 AHP 时） ├── output/ # 结果表 + 图片 └── requirements.txt

这个切分的好处很直接：membership.py只依赖 numpy，可以单独拿去做单元测试；evaluate.py不关心数据从 Excel 还是数据库来，只认 numpy 数组。二次开发时你要换数据源，只动utils/io_utils.py；要加新的隶属函数，只动membership.py。改一个地方，不会连带影响其他地方。

evaluate.py是核心流程文件，它对外通常只暴露一个函数签名，长这样：

def evaluate(indicators, weights, level_params, level_scores, operator="weighted", normalize=True): """ indicators : (n_factors,) 一维指标实测值，或 (n_samples, n_factors) weights : (n_factors,) 权重向量，和必须为 1 level_params : list[(a, b, c)]，每个评语等级对应的三角隶属函数三参数 level_scores : (n_levels,) 等级分数向量，如 [95, 82, 68, 50] operator : max_min / max_prod / min_sum / weighted normalize : 是否把 B 归一化到和为 1 """

参数顺序不是随便排的。indicators放第一位，因为它是唯一每次调用都会变的东西；level_params和level_scores属于“一次配好、长期不动”的模型参数，所以放在后面。这个排法在批量评价几百条记录时，用functools.partial把后四个参数固定住就行。

2.2 依赖清单与版本约束

依赖不复杂，但有两处版本上的隐患值得先说：

numpy>=1.21,<2.0 pandas>=1.3 openpyxl>=3.0 matplotlib>=3.4 pyyaml>=5.4

numpy上面卡了<2.0的上界。numpy 2.x 在类型提升规则上做了一些调整，老代码里np.float_、np.alltrue这类别名直接被移除，而评价脚本里经常出现np.float_这种写法，升级之后就会直接报 AttributeError。血泪经验是：这类小工具脚本的依赖能固定就固定，不要贪新。

openpyxl是 pandas 读.xlsx的底层引擎，缺了它pd.read_excel只会抛一句Missing optional dependency 'openpyxl'，第一次遇到的时候容易误以为是路径写错了。

matplotlib只在出图时用到。如果服务器上没有图形界面，脚本里必须显式指定非交互后端，否则会卡在plt.show()：

import matplotlib matplotlib.use("Agg") # 必须在 import pyplot 之前 import matplotlib.pyplot as plt

matplotlib.use("Agg")要在import pyplot之前调用，顺序反了不生效——这是踩过不止一次的坑。

2.3 数据契约：Excel 模板的三张表

这套脚本对输入格式是有约定的，常见做法是用一张宽表加两段参数：

meta表是整份数据里最容易被忽略、也最容易出问题的地方。它定义了每个指标在“优/良/中/差”四档上的划分点，membership.py拿这些点去生成三角隶属函数。举例：某指标四档中心点是 90、80、70、60，两边各留 10 的过渡带，那“优”这一档的参数就是(80, 90, 100)，“良”是(70, 80, 90)，以此类推。

type列用来区分效益型（越大越好）和成本型（越小越好）。成本型指标不能直接套上面的三角参数，得先把数值取反或者做极差反向着处理，否则“能耗越低越好”会被算成“能耗越高越是优”。这类错误不会抛异常，结论错得却很彻底，属于典型的静默失败。

注意：indicators表的列顺序必须和meta表的行顺序、以及 AHP 判断矩阵的行列顺序三处完全一致。脚本里最好在入口处做一次列名校验，比事后排查省事得多。

3. 核心算法链路：从指标实测值到评判向量的四步实现

模糊综合评判的数学骨架其实只有一行：B = A ∘ R。但这一行里藏了四个决策点——R 怎么来、A 怎么定、∘ 用哪种算子、B 出来之后怎么定级。四个点任意一个选错，最终等级都会偏。下面按数据流顺序拆。

3.1 第一步：用隶属函数把实测值翻成隶属度矩阵 R

R 是一个n×m的矩阵，n 是指标个数，m 是评语等级个数。第 i 行第 j 列的元素r_ij表示“第 i 个指标属于第 j 档的程度”，取值在 0 到 1 之间。

最常用的是三角形隶属函数，形参只有三个点：左零点 a、峰值点 b、右零点 c。

import numpy as np def tri_mf(x, a, b, c): """三角形隶属函数：x<=a 或 x>=c 时为 0，x==b 时为 1，中间线性过渡""" x = np.asarray(x, dtype=float) y = np.zeros_like(x) left = (x > a) & (x <= b) # 上升段 right = (x > b) & (x < c) # 下降段 y[left] = (x[left] - a) / (b - a) y[right] = (c - x[right]) / (c - b) y[x == b] = 1.0 # 峰值点单独赋值，避免 0/0 return y

b - a和c - b做分母，所以三个参数必须严格递增a < b < c。如果meta表里某一档的划分点写成了相邻档位重合，这里就会触发除零或者产生 inf，后面整条链路都跟着坏掉。

有了单点函数，逐指标逐等级填矩阵：

def build_R(x_row, level_params): """ x_row : (n_factors,) 一条样本的指标实测值 level_params: list[(a,b,c)]，长度等于评语等级数 m，从高档到低档排列 返回 R : (n_factors, m) """ n, m = len(x_row), len(level_params) R = np.zeros((n, m)) for i, x in enumerate(x_row): for j, (a, b, c) in enumerate(level_params[i]): R[i, j] = tri_mf(x, a, b, c) return R

注意level_params是二维的——每个指标有自己的一套等级划分点，不是全局共用一套。这点很重要：不同量纲的指标（满意度打 0-100 分、故障率是 0-5%）不可能共用同一组 a、b、c。

写完之后必须做逐行检查：某一行的和如果为 0，说明这个指标的实测值完全落在所有等级的隶属函数支撑区间之外，比如填了个 999 的异常值。这时要么报错拦住，要么做保底归一化：

row_sum = R.sum(axis=1, keepdims=True) R = np.divide(R, row_sum, out=np.full_like(R, 1.0 / R.shape[1]), where=row_sum > 0)

np.divide的where参数配合out预设值，是处理这类“部分行正常、部分行异常”的标准写法，避免整表崩掉。但保底值1/m意味着“这个指标对各档同等可能”，等于放弃了这个指标的信息量，所以最好还是在上游把异常值拦掉，保底只作为保底。

3.2 第二步：权重向量 A 的三条来源

权重决定谁说话算数，是整套流程里主观性最强的部分。

AHP 层次分析法，靠 1-9 标度构造判断矩阵，取最大特征值对应的特征向量归一化：

def ahp_weight(A): """A: (n,n) 正互反判断矩阵，a_ij 表示 i 相对 j 的重要度""" A = np.asarray(A, dtype=float) n = A.shape[0] vals, vecs = np.linalg.eig(A) k = int(np.argmax(vals.real)) lam = vals.real[k] # 最大特征值 w = np.abs(vecs[:, k].real) w = w / w.sum() # 归一化权重 RI = {1: 0, 2: 0, 3: 0.58, 4: 0.90, 5: 1.12, 6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45} CI = (lam - n) / (n - 1) if n > 1 else 0.0 CR = CI / RI[n] if RI.get(n, 0) else 0.0 # 一致性比率 return w, CR

CR是必须返回的，不能只返回权重。判断矩阵是人填的，前后矛盾很常见（A 比 B 重要、B 比 C 重要、C 又比 A 重要），CR > 0.1就说明这份判断矩阵不可用，权重数字再漂亮也没有意义。这一步如果不检查，相当于把一个错误的前提输入到后面的计算里。

熵权法走的是完全相反的路径，不靠人判断，靠数据本身的离散程度：

def entropy_weight(X): """X: (n_samples, n_factors)，已正向化并归一化到非负""" n, _ = X.shape P = X / X.sum(axis=0, keepdims=True) P = np.clip(P, 1e-12, None) # 关键：避免 ln(0) k = 1.0 / np.log(n) e = -k * (P * np.log(P)).sum(axis=0) # 信息熵，越分散越接近 1 d = 1 - e # 差异系数 return d / d.sum()

np.clip那一行是可维护性的分界点。标准化之后出现 0 是很正常的（最小值减最小值就是 0），ln(0)得到-inf，乘上 0 变成nan，然后整个权重向量都是 nan，报错信息还指向一段看起来完全正确的矩阵乘法。看到nan先从对数下手。

熵权法还有个前提容易被漏掉：样本量 n 太小的时候熵值没有统计意义。三五条样本算出来的权重，本质上就是噪声。

变异系数法最简单，用标准差除以均值衡量离散度，适合指标量纲统一、样本量中等的场景：

def cv_weight(X): """X: (n_samples, n_factors)""" mean = X.mean(axis=0) std = X.std(axis=0, ddof=1) v = std / np.where(mean == 0, 1e-12, mean) # 防均值为 0 return v / v.sum()

实践中常见的做法是两条腿走路：AHP 出一份带专家意图的权重，熵权法出一份纯数据权重，再用乘法合成w = (w_ahp * w_ew) / sum(w_ahp * w_ew)。合成之后主观和客观都不至于极端，代价是解释起来要多说两句。

3.3 第三步：模糊合成算子选哪个

B = A ∘ R里的 ∘ 不是普通矩阵乘法，有四种经典定义，行为差别很大：

四种算子的实现：

def fuzzy_compose(A, R, op="weighted"): """A: (n,) 权重; R: (n, m) 隶属度矩阵; 返回 B: (m,)""" A = np.asarray(A, dtype=float).ravel() R = np.asarray(R, dtype=float) if op == "max_min": # M(∧,∨) return np.minimum(A[:, None], R).max(axis=0) if op == "max_prod": # M(·,∨) return (A[:, None] * R).max(axis=0) if op == "min_sum": # M(∧,⊕) return np.minimum(1.0, np.minimum(A[:, None], R).sum(axis=0)) if op == "weighted": # M(·,⊕) b = (A[:, None] * R).sum(axis=0) return b / b.sum() if b.sum() > 0 else b raise ValueError("未知算子: %s" % op)

A[:, None]是把一维权重扩成列向量，和R广播成n×m，省掉一层循环。weighted分支末尾做了归一化，是因为浮点累加之后 B 的和可能是 0.9999999，后面按分数加权时会有肉眼可见的尾差。

选哪个？综合评价场景下基本都用 M(·,⊕)。它的语义最接近“加权平均”，所有指标的信息都参与进来，不会因为某一个指标极端就把结论带偏。M(∧,∨) 的问题在于它只认最突出的那一个，其余指标全部被丢弃；但如果业务上确实存在“某个指标不合格就整体不合格”的硬性要求，那 M(∧,∨) 反而是对的选择。

真正会翻车的场景是中途换算子却不重算权重。M(·,∨) 和 M(·,⊕) 对权重量级的敏感度完全不同，AHP 那套和为 1 的权重放到 M(·,∨) 下面，经常会出现所有a_i · r_ij都很小、B 向量整体贴地的情况，看着像程序出错，其实是算子选错了。

3.4 第四步：定级与还原成分数

拿到 B 之后要做两件事：定等级、出分数。

定等级用最大隶属度原则，取分量最大的那一档：

level_idx = int(np.argmax(B)) level_name = LEVELS[level_idx]

但最大隶属度原则有个已知缺陷：当 B 的前两个分量很接近时（比如 0.38 和 0.36），结论实际上是模糊的，强行取最大值的可信度不高。稳妥一点的做法是加一道差值判断：

order = np.argsort(B)[::-1] gap = B[order[0]] - B[order[1]] if gap < 0.05: level_name = "%s/%s 之间" % (LEVELS[order[0]], LEVELS[order[1]])

出分数则用等级分数向量做加权平均，把模糊向量还原成一个可比的标量：

LEVEL_SCORES = np.array([95.0, 82.0, 68.0, 50.0]) # 优/良/中/差 score = float(B @ LEVEL_SCORES)

B @ LEVEL_SCORES是点积，等价于sum(b_j * s_j)。这一步的物理含义是“按隶属度对各档分数做加权期望”，比直接取最大档对应的分数平滑得多，排序时也更有区分度。两个对象都是“良”，一个 82.5 一个 78.9，看名称分不出来，看分数就能排。

一个前置校验不能省：LEVELS、LEVEL_SCORES、level_params三者的长度必须都等于 m。如果config.yaml里加了一档评语但忘了改分数向量，numpy 的点积会直接抛 shape 不匹配——这算好的；如果长度刚好凑上但语义错位（比如分数向量写成了升序），那结论会静默反转，这才是最难查的那种。

4. 跑通与复现：环境、配置项和一次端到端执行

算法链路清楚之后，剩下的问题是把它在自己机器上跑起来，并且换成自己的数据。这一节按实际操作顺序走一遍。

4.1 建环境与装依赖

先隔离环境，别往系统 Python 里装：

cd fuzzy_eval python -m venv .venv source .venv/bin/activate # Windows 下用 .venv\Scripts\activate python -V # 确认 3.8 以上 pip install -r requirements.txt

python -V这一步不是走形式。requirements.txt里如果写了numpy>=1.21，而本地是 3.7，pip 会去找一个老版本 numpy，装完之后 import 报的错跟 numpy 版本毫无关系，排查方向一开始就是偏的。

装完先做一次冒烟测试，确认的是包能不能导入，而非算法对不对：

python -c "from fuzzy.membership import tri_mf; print(tri_mf(85, 80, 90, 100))"

输出应该是0.5。如果这一步报ModuleNotFoundError: No module named 'fuzzy'，大概率是在fuzzy_eval/之外执行了命令，sys.path里没有当前目录。加一句export PYTHONPATH=.或者在包根目录下执行，问题就解决了。

4.2 配置文件里改什么

config.yaml是所有模型参数的集中地，改它不用碰代码：

project: 履约情况评价 levels: [优, 良, 中, 差] # 评语集 V，从高到低 level_scores: [95, 82, 68, 50] # 与 levels 一一对应 operator: weighted # max_min / max_prod / min_sum / weighted weight_method: ahp # ahp / entropy / cv / combine normalize: true output: dir: output plot: true

四个字段是需要重点理解的：

levels的顺序决定了level_params的列顺序和level_scores的顺序，三处必须同步改。把levels改成带五档，但level_scores还是四个数，前面说过，会触发形状不匹配。

operator换成max_min之前，建议先在样本量小的时候对比一下weighted的结果差异。两者的结论经常不是“略有不同”，而是直接换了一档，这时要判断哪个更符合业务直觉，而不是哪个看起来更“专业”。

weight_method选ahp时脚本会去读data/ahp_matrix.xlsx；选entropy或cv就完全跳过这个文件，权重从样本数据现算。数据量少于 10 条时不要用熵权法，前面说过原因。

normalize设为false会保留原始 B 值，方便检查算子行为的中间结果。日常跑流程保持true。

4.3 一次端到端运行与输出解读

准备一份自己的indicators.xlsx，命令行执行：

python main.py \ --config config.yaml \ --input data/indicators.xlsx \ --out output/

--config指定模型参数文件，--input指定指标实测值，--out是输出目录，不存在会自动创建。跑完之后目录里有三样东西：

output/ ├── result.csv # object_id, level, score, b_优, b_良, b_中, b_差 ├── result.xlsx # 同上，多一个汇总页 └── fig_B.png # 首条样本的评判向量柱状图

result.csv里把 B 的每个分量都落成了列，这个设计很实用——只看level那一列看不出结论有多“险”，把b_优和b_良摆在一起，0.51 对 0.47 这种情况一眼就能认出来，该不该人工复核也就有依据了。

跑完先做三项检查，比直接看结论更有效：

第一项，b_优 + b_良 + b_中 + b_差每行是否都接近 1。有偏差说明归一化没生效，或者某个指标的隶属度整行为 0 走了保底。

第二项，score的分布范围。如果全部挤在 68 到 70 之间，通常是隶属函数参数太窄，所有指标都落在了过渡带上，等于所有指标的信息被平均掉了。这时回头调meta表里的划分点，把档位中心拉开。

第三项，抽一条object_id，手算一遍它的 R 和 B。手算只要三五分钟，但能把“脚本算错了”和“我的模型设定有问题”这两件事彻底分开。

4.4 二级综合评判怎么接

指标一多（超过 8 个），两两比较的判断矩阵基本没法填，一致性也过不了。这时的标准做法是分层：把指标分成几个大类，类内先做一次一级评判，类间再做一次二级评判。

# 第一层：三个大类各自的一级评判 groups = { "质量": {"idx": [0, 1, 2], "A": np.array([0.5, 0.3, 0.2])}, "进度": {"idx": [3, 4], "A": np.array([0.6, 0.4])}, "成本": {"idx": [5, 6, 7], "A": np.array([0.4, 0.35, 0.25])}, } B1 = [] for name, g in groups.items(): R_sub = R[g["idx"], :] # 从全局 R 里切出本类的行 B1.append(fuzzy_compose(g["A"], R_sub, op)) R_second = np.vstack(B1) # (3, m) 二级隶属度矩阵 A_second = np.array([0.5, 0.25, 0.25]) # 三个大类之间的权重 B = fuzzy_compose(A_second, R_second, op)

关键是R[g["idx"], :]这一行：一级评判不重新算隶属度，直接在全局 R 上按行切片。这样隶属函数只跑一次，多级评判只是在矩阵上做分组运算，效率高，也不会出现两级用了不同隶属函数参数的不一致问题。

np.vstack(B1)把三个一维向量摞成3×m矩阵，这一步之后二级评判和一级评判调的是同一个fuzzy_compose，代码不用改。

层级结构最好也放进config.yaml，而不是硬编码在 Python 里：

hierarchy: - name: 质量 factors: [合格率, 返修率, 客户满意度] weights: [0.5, 0.3, 0.2] - name: 进度 factors: [按期交付率, 平均延期天数] weights: [0.6, 0.4] group_weights: [0.5, 0.25, 0.25]

factors写指标名而不是索引，指标增删的时候不用回头数下标，这是把配置和数据解耦的关键一步。

5. 避坑与排查：五个让我返工的翻车点

这套流程的调试体验有点玄学——不抛异常，但结论就是不对。下面五条是实际操作里最容易撞上的，每条都按现象、原因、解决拆开。

5.1 评判向量整行是 NaN，但没有任何报错

现象：result.csv里b_优到b_差全是nan，level列空着，程序退出码是 0。

原因：某个指标的隶属度整行为 0，B.sum()也是 0，weighted分支里b / b.sum()变成0/0。常见触发源是 Excel 里混进了空单元格或者文本型的“—”，pandas 读进来是NaN，tri_mf里所有比较运算对NaN都返回 False，整行就全是 0。

解决：在读数后立刻做一次显式检查，别指望下游兜住：

import numpy as np from utils.io_utils import read_indicators X = read_indicators("data/indicators.xlsx") bad = np.isnan(X).any(axis=1) if bad.any(): raise ValueError("这些行有缺失值: %s" % list(np.where(bad)[0]))

抛出比静默返回 NaN 好得多。如果业务上确实允许缺失，就在入口处用列均值填充，并打印一条警告，把处理痕迹落在日志里。

5.2 权重和为 1，但结论明显偏向某一个指标

现象：检查过A.sum()等于 1.0，可是结论和那个权重最大的指标几乎完全同步。

原因：八成是算子选了max_min或者max_prod。这两种算子只保留最突出的那个分量，权重小的指标哪怕隶属度拉满也不影响结果。A.sum() == 1只能说明权重合法，不能说明权重被用上了。

解决：先打印 B 看看是不是只有一两个非零分量：

print("B =", np.round(B, 4), "非零分量数 =", (B > 1e-6).sum())

非零分量数明显小于指标数，基本就能确认是算子的问题。换回weighted重跑对比。如果业务上就是需要主因素决定（比如安全类指标一票否决），那保留max_min，但要在文档里写清楚“本评价为主因素决定型”，否则后面接手的人一定会怀疑权重算错了。

5.3 熵权法算出负权重或者权重全一样

现象：entropy_weight返回的向量里有负值；或者所有指标权重几乎是1/n。

原因：负权重来自ln(0)——标准化后某一列全是同一个值，P全是 0，clip之后ln(1e-12)是个大负数，熵值e冲出[0,1]区间，d = 1 - e就成了负数。权重全一样则相反：某一列在样本间完全没差异，e接近 1，d接近 0，所有列都接近 0 的时候归一化出来就退化成均匀分布。

解决：在算熵之前判一次列方差，把无差异的列剔掉或者给一个下限：

def entropy_weight_safe(X, eps=1e-9): std = X.std(axis=0) if (std < eps).any(): drop = np.where(std < eps)[0] print("警告: 以下指标无区分度，权重置 0:", drop) keep = std >= eps w = np.zeros(X.shape[1]) w[keep] = entropy_weight(X[:, keep]) return w / w.sum() return entropy_weight(X)

同时clip的下界从1e-12抬到1e-9，并且加一句e = np.clip(e, 0.0, 1.0)作为保底处理。这个保底看着有点丑，但确实能把偶发的数值问题限制在一个指标内，不会扩散到整个权重向量。

5.4 AHP 一致性比率 0.23，但权重看起来“挺合理”

现象：ahp_weight返回的CR是 0.23，远超 0.1，可权重数值看着完全符合预期，就跳过了没管。

原因：判断矩阵是人填的，n 大于 5 之后，人脑很难维持前后一致的传递性。CR超标意味着这个矩阵里存在循环矛盾（A>B、B>C、C>A），特征向量虽然能算出来，但它代表的不是一个自洽的偏好结构。在这种情况下，权重只是把矛盾“平均”掉了。

解决：CR > 0.1必须返工，没有例外。两个做法：一是减少一次比较的指标数量，超过 7 个就分组做二级评判；二是让填表的人先给出一个排序，再按排序填数值，比直接填 1-9 标度的九宫格一致性好得多。CR记得打印出来，不要只返回权重：

w, cr = ahp_weight(A) print("AHP 权重 =", np.round(w, 4), "CR =", round(cr, 4)) assert cr < 0.1, "判断矩阵一致性不达标，CR=%.3f" % cr

5.5 最大隶属度原则给出反直觉的等级

现象：某个对象各项指标表现都不错，所有b分量里b_优也确实是最大的，但只比b_良高 0.02，定成“优”，业务方不认。

原因：最大隶属度原则在 B 的前两个分量接近时判别力不足，这时候结论本质上是不确定的。直接用argmax相当于把这个不确定性隐藏了起来。

解决：加一道差值阈值，把“险胜”的情况单独标出来交人工复核，同时用加权分数辅助排序：

order = np.argsort(B)[::-1] if B[order[0]] - B[order[1]] < 0.05: level = "%s/%s待定" % (LEVELS[order[0]], LEVELS[order[1]]) else: level = LEVELS[order[0]] score = float(B @ LEVEL_SCORES)

阈值 0.05 不是固定标准，样本量大的时候可以用历史复核结论反推：统计被人工推翻的那些记录，看它们的差值分布落在哪个区间，阈值就取那个区间上沿。比直接沿用通用经验值靠谱得多。

6. 二次开发：把通用脚本改造成自己的评价引擎

这套脚本最好的地方，是它的计算内核和业务是分开的，所以二次开发的重点在接口层面，算法本身不用碰。三个我实际做过的方向：

一、把模型的参数抽成可注册的配置。现在membership.py里的函数是写死的几种，每次新增指标类型都要改代码。改成注册表之后，业务侧只要在 yaml 里写函数名就能选：

MF_REGISTRY = {"tri": tri_mf, "trap": trap_mf, "gauss": gauss_mf} def get_mf(name): if name not in MF_REGISTRY: raise KeyError("未注册的隶属函数: %s，可选 %s" % (name, list(MF_REGISTRY))) return MF_REGISTRY[name]

meta表加一列mf_type，build_R里按行取函数。新增一种隶属函数只要往MF_REGISTRY里加一行。

二、把evaluate包成 HTTP 接口。用 FastAPI 十几行就够，注意别再传 DataFrame 进去，收原始 dict 更稳：

from fastapi import FastAPI from pydantic import BaseModel from fuzzy.evaluate import evaluate app = FastAPI() class EvalReq(BaseModel): indicators: list[float] @app.post("/evaluate") def do_eval(req: EvalReq): B, level, score = evaluate(req.indicators, WEIGHTS, LEVEL_PARAMS, LEVEL_SCORES) return {"B": B.tolist(), "level": level, "score": score}

WEIGHTS这些在启动时从配置读一次、缓存成模块级变量，别每次请求重新算 AHP 特征向量，那是纯浪费。

三、用基准样本做回归测试。这是我最推荐的一条。挑五条覆盖不同档位的样本，把当前跑出来的B和score存成 JSON，写成 pytest：

import json, numpy as np, pytest from fuzzy.evaluate import evaluate @pytest.mark.parametrize("case", json.load(open("tests/golden.json"))) def test_golden(case): B, level, score = evaluate(np.array(case["x"]), WEIGHTS, LEVEL_PARAMS, LEVEL_SCORES) assert np.allclose(B, case["B"], atol=1e-6) assert abs(score - case["score"]) < 1e-6

之后无论谁动membership.py还是operator.py，跑一遍就知道有没有破环已有结论。

第三行的风险是我真实遇到过的：基准 JSON 是用一个参数配错的config.yaml跑出来的，之后所有测试都在保护一个错误结果，直到换了个业务方复核才发现。从那以后我每次生成基准数据，都强制走一遍“手算三条 + 换人复核”的流程，再写进golden.json。模型参数这种东西，一旦被固化成测试基准，错的也会变成“对的”。希望这套拆解能帮到你，少走几步弯路。

本文还有配套的精品资源，点击获取