层次分析法（AHP）Python 实战：3步构建决策模型，CR值＜0.1验证

层次分析法（AHP）Python实战：从理论到代码实现

引言

在日常生活和工作中，我们经常面临需要做出复杂决策的场景。比如选择旅游目的地时，需要在景色、费用、交通便利性等多个因素之间权衡；企业采购设备时，需要综合考虑价格、性能、售后服务等不同维度的指标。这类多准则决策问题往往难以用简单的"是"或"否"来回答，而层次分析法（Analytic Hierarchy Process, AHP）正是为解决这类问题而生的有力工具。

AHP由美国运筹学家Thomas L. Saaty于20世纪70年代提出，它将复杂问题分解为目标、准则、方案等层次，通过定性分析与定量计算相结合的方式，为决策提供科学依据。与传统的决策方法相比，AHP具有以下显著优势：

• 系统性：将问题分解为有序的层次结构
• 简洁性：基于两两比较的判断方式更符合人类思维习惯
• 实用性：定性与定量相结合，适用于复杂决策场景
• 灵活性：可广泛应用于各种领域的决策问题

本文将重点介绍如何使用Python实现AHP的核心算法，包括判断矩阵构建、权重计算和一致性检验等关键步骤，并通过旅游地选择的实际案例演示完整应用流程。针对有一定Python基础的数据分析师和学生读者，我们将提供可直接运行的代码示例，帮助您快速掌握这一实用决策工具。

1. AHP基础理论与算法原理

1.1 AHP的基本步骤

层次分析法的实施通常包含以下几个关键步骤：

1. 建立层次结构模型：将决策问题分解为目标层、准则层和方案层
2. 构造判断矩阵：对同一层次的要素进行两两比较，建立判断矩阵
3. 计算权重向量：通过数学方法计算各要素的相对权重
4. 一致性检验：验证判断矩阵的逻辑一致性
5. 层次总排序：计算各方案对总目标的综合权重

1.2 判断矩阵与标度理论

判断矩阵是AHP的核心概念，它表示同一层次各要素相对于上一层次某要素的重要性比较。Saaty提出了1-9标度法作为比较的标准：

判断矩阵A具有以下性质：

• aᵢᵢ = 1 （对角线元素为1）
• aᵢⱼ = 1/aⱼᵢ （互反性）

1.3 权重计算方法

常用的权重计算方法有三种：

1. 算术平均法（和法）

def calculate_weights_by_am(matrix): n = matrix.shape[0] # 按列归一化 normalized = matrix / matrix.sum(axis=0) # 按行求平均 weights = normalized.mean(axis=1) return weights

2. 几何平均法（根法）

def calculate_weights_by_gm(matrix): n = matrix.shape[0] # 计算几何平均 row_products = np.prod(matrix, axis=1) roots = np.power(row_products, 1/n) # 归一化 weights = roots / roots.sum() return weights

3. 特征向量法

def calculate_weights_by_ev(matrix): eigenvalues, eigenvectors = np.linalg.eig(matrix) max_idx = np.argmax(eigenvalues) weights = np.real(eigenvectors[:, max_idx]) # 归一化 weights = weights / weights.sum() return weights

1.4 一致性检验

一致性检验是确保判断矩阵逻辑合理性的关键步骤，主要指标包括：

• 一致性指标CI：CI = (λₘₐₓ - n)/(n - 1)
• 随机一致性指标RI：与矩阵阶数相关的常数
• 一致性比率CR：CR = CI/RI

当CR < 0.1时，认为判断矩阵的一致性可以接受。

def consistency_check(matrix, weights): n = matrix.shape[0] # 计算最大特征值 weighted_sum = np.dot(matrix, weights) lambda_max = np.mean(weighted_sum / weights) # 计算CI CI = (lambda_max - n) / (n - 1) # RI值查表 RI_dict = {1: 0, 2: 0, 3: 0.52, 4: 0.89, 5: 1.12, 6: 1.26, 7: 1.36, 8: 1.41, 9: 1.46} RI = RI_dict.get(n, 1.49) # 对于n>9的情况 # 计算CR CR = CI / RI return CR

2. Python实现AHP完整流程

2.1 环境准备与依赖安装

在开始编码前，我们需要准备Python环境并安装必要的依赖库：

pip install numpy pandas

2.2 AHP核心类实现

下面我们实现一个完整的AHP类，封装所有核心功能：

import numpy as np class AHP: def __init__(self, matrix): self.matrix = np.array(matrix) self.n = self.matrix.shape[0] self.weights = None self.CR = None def calculate_weights(self, method='geometric_mean'): """计算权重向量""" if method == 'arithmetic_mean': normalized = self.matrix / self.matrix.sum(axis=0) self.weights = normalized.mean(axis=1) elif method == 'geometric_mean': row_products = np.prod(self.matrix, axis=1) roots = np.power(row_products, 1/self.n) self.weights = roots / roots.sum() elif method == 'eigenvector': eigenvalues, eigenvectors = np.linalg.eig(self.matrix) max_idx = np.argmax(eigenvalues) self.weights = np.real(eigenvectors[:, max_idx]) self.weights = self.weights / self.weights.sum() else: raise ValueError("Invalid method. Choose from 'arithmetic_mean', 'geometric_mean', 'eigenvector'") return self.weights def check_consistency(self): """一致性检验""" if self.weights is None: raise ValueError("Weights not calculated yet. Call calculate_weights() first.") weighted_sum = np.dot(self.matrix, self.weights) lambda_max = np.mean(weighted_sum / self.weights) CI = (lambda_max - self.n) / (self.n - 1) RI_dict = {1: 0, 2: 0, 3: 0.52, 4: 0.89, 5: 1.12, 6: 1.26, 7: 1.36, 8: 1.41, 9: 1.46} RI = RI_dict.get(self.n, 1.49) self.CR = CI / RI return self.CR def is_consistent(self, threshold=0.1): """判断是否通过一致性检验""" if self.CR is None: self.check_consistency() return self.CR < threshold def analyze(self, method='geometric_mean', threshold=0.1): """完整分析流程""" self.calculate_weights(method) self.check_consistency() print(f"Weights: {self.weights}") print(f"Consistency Ratio (CR): {self.CR:.4f}") if self.is_consistent(threshold): print("Consistency check passed (CR < 0.1)") else: print("Warning: Consistency check failed (CR >= 0.1)") return self.weights, self.CR

2.3 旅游地选择案例实战

假设我们需要在三个旅游目的地（桂林、黄山、北戴河）之间做出选择，考虑以下五个准则：

1. 景色
2. 费用
3. 居住条件
4. 饮食
5. 交通便利性

步骤1：构建准则层判断矩阵

# 准则层判断矩阵 (景色, 费用, 居住, 饮食, 交通) criteria_matrix = [ [1, 1/3, 3, 1/2, 2], # 景色 [3, 1, 5, 3, 4], # 费用 [1/3, 1/5, 1, 1/3, 1/2], # 居住 [2, 1/3, 3, 1, 2], # 饮食 [1/2, 1/4, 2, 1/2, 1] # 交通 ] ahp_criteria = AHP(criteria_matrix) criteria_weights, cr = ahp_criteria.analyze()

步骤2：构建方案层对各准则的判断矩阵

# 方案层对各准则的判断矩阵 # 景色 scenery_matrix = [ [1, 1/3, 1/5], # 桂林 [3, 1, 1/3], # 黄山 [5, 3, 1] # 北戴河 ] # 费用 cost_matrix = [ [1, 3, 5], # 桂林 [1/3, 1, 3], # 黄山 [1/5, 1/3, 1] # 北戴河 ] # 居住 living_matrix = [ [1, 3, 1/2], # 桂林 [1/3, 1, 1/3], # 黄山 [2, 3, 1] # 北戴河 ] # 饮食 food_matrix = [ [1, 3, 3], # 桂林 [1/3, 1, 1], # 黄山 [1/3, 1, 1] # 北戴河 ] # 交通 traffic_matrix = [ [1, 1/3, 1/4], # 桂林 [3, 1, 1/3], # 黄山 [4, 3, 1] # 北戴河 ] # 计算各方案对各准则的权重 ahp_scenery = AHP(scenery_matrix) scenery_weights = ahp_scenery.calculate_weights() ahp_cost = AHP(cost_matrix) cost_weights = ahp_cost.calculate_weights() ahp_living = AHP(living_matrix) living_weights = ahp_living.calculate_weights() ahp_food = AHP(food_matrix) food_weights = ahp_food.calculate_weights() ahp_traffic = AHP(traffic_matrix) traffic_weights = ahp_traffic.calculate_weights()

步骤3：计算综合得分并排序

# 组合各方案权重矩阵 alternative_weights = np.vstack([ scenery_weights, cost_weights, living_weights, food_weights, traffic_weights ]) # 计算综合得分 total_scores = np.dot(criteria_weights, alternative_weights) # 输出结果 destinations = ['桂林', '黄山', '北戴河'] for dest, score in zip(destinations, total_scores): print(f"{dest}: {score:.4f}") # 找出最佳选择 best_idx = np.argmax(total_scores) print(f"\n最佳选择是: {destinations[best_idx]}")

3. 高级应用与优化技巧

3.1 处理不一致判断矩阵

当CR ≥ 0.1时，我们需要调整判断矩阵。以下是一些实用技巧：

1. 自动调整算法：

def adjust_matrix(matrix, max_iter=100): adjusted = matrix.copy() ahp = AHP(adjusted) ahp.calculate_weights() cr = ahp.check_consistency() iter_count = 0 while cr >= 0.1 and iter_count < max_iter: # 找出不一致性最大的元素 weighted_sum = np.dot(adjusted, ahp.weights) consistency_vector = weighted_sum / (ahp.weights * ahp.n) idx = np.argmax(np.abs(consistency_vector - 1)) i, j = np.unravel_index(idx, adjusted.shape) # 调整该元素 adjusted[i,j] = (adjusted[i,j] + 1/adjusted[j,i]) / 2 adjusted[j,i] = 1 / adjusted[i,j] # 重新计算 ahp = AHP(adjusted) ahp.calculate_weights() cr = ahp.check_consistency() iter_count += 1 return adjusted, cr

2. 人工调整建议：

• 检查极端值（如9或1/9）
• 验证是否存在逻辑矛盾（如A>B, B>C但C>A）
• 考虑重新进行两两比较

3.2 大规模AHP问题的优化

对于指标较多的复杂问题，可以采用以下优化策略：

1. 分组比较法：

• 将大量指标分组
• 先比较组间重要性
• 再比较组内指标重要性

2. 近似算法：

def approximate_weights(matrix, epsilon=1e-6): n = matrix.shape[0] weights = np.ones(n) / n # 初始等权重 while True: new_weights = np.dot(matrix, weights) new_weights /= new_weights.sum() if np.max(np.abs(new_weights - weights)) < epsilon: break weights = new_weights return weights

3.3 与其他决策方法的结合

AHP可以与其他决策方法结合使用，形成更强大的决策支持系统：

1. AHP-TOPSIS组合：

• 使用AHP确定指标权重
• 使用TOPSIS进行方案排序

2. AHP-模糊综合评价：

• 使用AHP确定权重
• 使用模糊数学处理不确定性

4. 实际应用中的注意事项

4.1 常见问题与解决方案

4.2 提高AHP结果可靠性的方法

1. 多专家决策：

def aggregate_judgments(matrices, method='geometric_mean'): """聚合多个专家的判断矩阵""" stacked = np.stack(matrices) if method == 'geometric_mean': aggregated = np.exp(np.mean(np.log(stacked), axis=0)) else: # arithmetic_mean aggregated = np.mean(stacked, axis=0) # 保持互反性 n = aggregated.shape[0] for i in range(n): for j in range(i+1, n): aggregated[i,j] = (aggregated[i,j] + 1/aggregated[j,i])/2 aggregated[j,i] = 1 / aggregated[i,j] return aggregated

2. 敏感性分析：

def sensitivity_analysis(ahp, variation=0.1, trials=100): """权重敏感性分析""" original_weights = ahp.weights.copy() n = ahp.n results = [] for _ in range(trials): # 随机扰动判断矩阵 perturbed = ahp.matrix * (1 + variation * np.random.randn(n, n)) np.fill_diagonal(perturbed, 1) # 保持对角线为1 perturbed = (perturbed + 1/perturbed.T)/2 # 保持互反性 # 计算新权重 ahp_perturbed = AHP(perturbed) new_weights = ahp_perturbed.calculate_weights() results.append(new_weights) return np.array(results)

4.3 AHP的局限性及替代方案

虽然AHP是一种强大的决策工具，但它也有一定的局限性：

1. 局限性：

• 指标数量较多时，两两比较工作量大
• 仍然包含主观判断成分
• 对判断矩阵的一致性敏感

2. 替代方案：

• ANP（网络分析法）：处理指标间存在依赖关系的情况
• DEMATEL：适用于分析复杂因果关系
• BWM（最佳最差方法）：减少比较次数，提高一致性

5. 扩展应用与进阶学习

5.1 AHP在不同领域的应用案例

1. 供应商选择：

• 质量 (0.35)
• 价格 (0.25)
• 交货准时率 (0.2)
• 售后服务 (0.15)
• 技术能力 (0.05)

2. 项目风险评估：

risk_factors = { '技术风险': 0.3, '市场风险': 0.25, '财务风险': 0.2, '管理风险': 0.15, '法律风险': 0.1 }

3. 个人职业选择：

• 薪资待遇
• 发展空间
• 工作强度
• 公司文化
• 地理位置

5.2 使用Python库简化AHP实现

除了我们自己实现的AHP类，还可以使用现有库：

1. PyAHP：

pip install pyahp

2. 使用示例：

from pyahp import AHP, Method model = { "name": "Tourist Destination Selection", "method": "approximate", "criteria": ["scenery", "cost", "living", "food", "traffic"], "subCriteria": {}, "alternatives": ["Guilin", "Huangshan", "Beidaihe"], "preferenceMatrices": { "criteria": [[1,1/3,3,1/2,2], [3,1,5,3,4], ...], "scenery": [[1,1/3,1/5], [3,1,1/3], [5,3,1]], ... } } ahp_model = AHP(model) priorities = ahp_model.get_priorities()

5.3 进一步学习资源

1. 推荐书籍：

• 《决策分析：层次分析法》 Thomas L. Saaty
• 《多准则决策分析：方法与案例》

2. 在线课程：

• Coursera: "Decision Making and Risk Analysis"
• edX: "Data Science for Business Decision Making"

3. 学术论文：

• Saaty, T.L. (2008). "Relative measurement and its generalization in decision making"
• Ishizaka, A. (2013). "Analytic hierarchy process and its use in operations management"

在实际项目中应用AHP时，建议结合具体领域知识，合理设计层次结构，并通过敏感性分析验证结果的稳健性。对于特别重要的决策，可以考虑将AHP与其他决策方法结合使用，以获得更全面客观的分析结果。