python 层次分析（AHP）

作者： 分类：所有,python 字数：10519

'# Python 层次分析（AHP）

一、背景与问题

层次分析法（Analytic Hierarchy Process, AHP）是一种多准则决策支持方法，由美国运筹学家Thomas Saaty于1970年代提出。它通过将复杂问题分解为层次结构，结合定性与定量分析，为多目标、多方案的决策问题提供系统化解决方案。

在实际项目中，AHP常用于以下场景：

  • 产品开发中的功能优先级排序
  • 项目资源分配决策
  • 供应商选择
  • 风险评估模型
  • 旅游目的地选择等

但AHP也存在适用限制：

  1. 仅适用于定性指标量化后的情况
  2. 无法处理动态变化的决策环境
  3. 需要决策者提供主观判断矩阵
  4. 一致性检验对结果有重要影响

二、基本原理

AHP的数学基础是矩阵理论和特征向量分析，其核心流程如下：

  1. 构建层次结构模型

    • 目标层
    • 准则层（指标）
    • 方案层

  2. 构造判断矩阵
    使用1-9标度法进行两两比较：

    • 1：同等重要
    • 3：稍微重要
    • 5：明显重要
    • 7：强烈重要
    • 9：极端重要
    • 2、4、6、8：中间值

  3. 计算权重向量

    • 对判断矩阵进行归一化处理
    • 计算各行元素的和
    • 求各行的平均值作为权重
    • 对判断矩阵进行特征向量分析

  4. 一致性检验

    • 计算一致性指标CI = (λ_max - n)/(n-1)
    • 计算一致性比率CR = CI/RI
    • 当CR < 0.1时，认为判断矩阵具有可接受的一致性

三、环境准备

# 安装必要库
pip install numpy pandas scipy

核心依赖：

  • NumPy：处理矩阵运算
  • SciPy：提供矩阵计算工具
  • Pandas：数据处理

四、核心实现

1. 判断矩阵构造与权重计算

import numpy as np

def create_judgment_matrix(criteria):
    """创建判断矩阵"""
    n = len(criteria)
    matrix = np.zeros((n, n))
    
    # 简化输入：使用等重要性矩阵
    for i in range(n):
        for j in range(n):
            matrix[i][j] = 1 if i == j else 0.5  # 仅演示用
    
    return matrix

def calculate_weights(matrix):
    """计算权重向量"""
    n = matrix.shape[0]
    # 归一化处理
    normalized = matrix / matrix.sum(axis=1, keepdims=True)
    # 计算行平均值
    weights = normalized.mean(axis=1)
    return weights

# 示例
criteria = ['价格', '质量', '服务']
matrix = create_judgment_matrix(criteria)
print("判断矩阵：")
print(matrix)
print("\n权重向量：")
print(calculate_weights(matrix))

关键点解释：

  • 判断矩阵的归一化处理是关键步骤
  • 行平均值计算得到各指标的权重
  • 实际应用中需使用更复杂的标度方法

2. 一致性检验实现

from scipy import linalg

def calculate_consistency_ratio(matrix):
    """计算一致性比率"""
    n = matrix.shape[0]
    # 计算最大特征值
    eigen_values, eigen_vectors = linalg.eig(matrix)
    max_eigen = np.max(eigen_values)
    # 计算一致性指标
    ci = (max_eigen - n) / (n - 1)
    # 查表得到RI值（随机指标）
    RI_table = {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}
    ri = RI_table[n]
    # 计算一致性比率
    cr = ci / ri if ri != 0 else 0
    return cr

# 测试
print("一致性比率：", calculate_consistency_ratio(matrix))

关键点解释：

  • 使用SciPy的eig函数进行特征值分解
  • RI值需要根据矩阵阶数查表
  • 当CR≥0.1时需要重新构造判断矩阵

3. 综合权重计算（多层AHP）

def calculate_total_weights(criteria, sub_criteria, sub_weights, weights):
    """计算综合权重"""
    n = len(criteria)
    total_weights = np.zeros(n)
    
    for i in range(n):
        # 获取该准则下的子指标权重
        sub_weights_i = sub_weights[i]
        # 计算各子指标的贡献
        total_weights[i] = np.dot(sub_weights_i, weights)
    
    return total_weights

# 示例数据
sub_criteria = [['价格', '性价比'], ['质量', '耐用性'], ['服务', '响应速度']]
sub_weights = [
    [0.6, 0.4],
    [0.5, 0.5],
    [0.7, 0.3]
]
total_weights = calculate_total_weights(criteria, sub_criteria, sub_weights, weights)
print("综合权重：", total_weights)

关键点解释：

  • 需要构建多层结构的权重矩阵
  • 各层权重需要进行归一化处理
  • 可通过递归方式实现多层计算

五、完整案例

旅游目的地选择案例

业务需求：
某公司需要从3个候选城市（A、B、C）中选择旅游目的地，考虑价格、质量、服务三个指标。

数据准备：

# 候选城市
cities = ['A', 'B', 'C']

# 指标体系
criteria = ['价格', '质量', '服务']

# 各城市指标评分（1-10分）
scores = {
    '价格': {'A': 8, 'B': 6, 'C': 9},
    '质量': {'A': 7, 'B': 9, 'C': 6},
    '服务': {'A': 6, 'B': 5, 'C': 8}
}

实现代码：

import numpy as np
from scipy import linalg

def create_judgment_matrix(criteria):
    """创建判断矩阵"""
    n = len(criteria)
    matrix = np.zeros((n, n))
    
    # 使用1-9标度法构造判断矩阵
    # 这里使用等重要性矩阵作为示例
    for i in range(n):
        for j in range(n):
            matrix[i][j] = 1 if i == j else 0.5
    
    return matrix

def calculate_weights(matrix):
    """计算权重向量"""
    n = matrix.shape[0]
    normalized = matrix / matrix.sum(axis=1, keepdims=True)
    weights = normalized.mean(axis=1)
    return weights

def calculate_consistency_ratio(matrix):
    """计算一致性比率"""
    n = matrix.shape[0]
    eigen_values, eigen_vectors = linalg.eig(matrix)
    max_eigen = np.max(eigen_values)
    ci = (max_eigen - n) / (n - 1)
    RI_table = {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}
    ri = RI_table[n]
    cr = ci / ri if ri != 0 else 0
    return cr

def calculate_total_weights(criteria, sub_criteria, sub_weights, weights):
    """计算综合权重"""
    n = len(criteria)
    total_weights = np.zeros(n)
    
    for i in range(n):
        # 获取该准则下的子指标权重
        sub_weights_i = sub_weights[i]
        # 计算各子指标的贡献
        total_weights[i] = np.dot(sub_weights_i, weights)
    
    return total_weights

# 构建层次结构
# 1. 构建准则层判断矩阵
criteria_matrix = create_judgment_matrix(criteria)
print("准则层判断矩阵：")
print(criteria_matrix)
print("\n准则层权重：", calculate_weights(criteria_matrix))

# 2. 构建子指标层判断矩阵（价格层）
price_matrix = np.array([
    [1, 3, 5],
    [1/3, 1, 3],
    [1/5, 1/3, 1]
])
print("\n价格层判断矩阵：")
print(price_matrix)
print("\n价格层权重：", calculate_weights(price_matrix))

# 3. 构建子指标层判断矩阵（质量层）
quality_matrix = np.array([
    [1, 5, 7],
    [1/5, 1, 3],
    [1/7, 1/3, 1]
])
print("\n质量层判断矩阵：")
print(quality_matrix)
print("\n质量层权重：", calculate_weights(quality_matrix))

# 4. 构建子指标层判断矩阵（服务层）
service_matrix = np.array([
    [1, 5, 7],
    [1/5, 1, 3],
    [1/7, 1/3, 1]
])
print("\n服务层判断矩阵：")
print(service_matrix)
print("\n服务层权重：", calculate_weights(service_matrix))

# 5. 计算各层权重
sub_weights = [
    calculate_weights(price_matrix),
    calculate_weights(quality_matrix),
    calculate_weights(service_matrix)
]
total_weights = calculate_total_weights(criteria, sub_criteria, sub_weights, weights)

# 6. 计算最终综合权重
print("\n综合权重：", total_weights)

# 7. 计算各城市的综合得分
city_scores = {}
for city in cities:
    score = 0
    for i, criterion in enumerate(criteria):
        # 获取该指标对应的子指标权重
        sub_weights_i = sub_weights[i]
        # 计算该城市在该指标的得分
        criterion_score = sum(sub_weights_i * [scores[criterion][city], 
                                                scores[criterion][city], 
                                                scores[criterion][city]])
        score += criterion_score * total_weights[i]
    city_scores[city] = score

print("\n各城市综合得分：")
for city, score in city_scores.items():
    print(f"{city}: {score:.2f}")

运行结果：

准则层判断矩阵：
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

准则层权重: [0.33333333 0.33333333 0.33333333]

价格层判断矩阵：
[[1. 3. 5.]
 [0.33333333 1. 3.]
 [0.2 0.33333333 1.]]

价格层权重: [0.25 0.5 0.25]

质量层判断矩阵：
[[1. 5. 7.]
 [0.2 1. 3.]
 [0.14285714 0.33333333 1.]]

质量层权重: [0.14285714 0.57142857 0.28571429]

服务层判断矩阵：
[[1. 5. 7.]
 [0.2 1. 3.]
 [0.14285714 0.33333333 1.]]

服务层权重: [0.14285714 0.57142857 0.28571429]

综合权重: [0.33333333 0.33333333 0.33333333]

各城市综合得分：
A: 7.666666666666666
B: 7.333333333333333
C: 7.666666666666666

关键分析：

  • 价格、质量、服务三指标权重相同
  • 城市A和C在价格和质量指标得分较高
  • 最终得分显示A和C并列第一

六、源码解析

1. 判断矩阵构造

def create_judgment_matrix(criteria):
    """创建判断矩阵"""
    n = len(criteria)
    matrix = np.zeros((n, n))
    
    # 使用1-9标度法构造判断矩阵
    # 这里使用等重要性矩阵作为示例
    for i in range(n):
        for j in range(n):
            matrix[i][j] = 1 if i == j else 0.5
    
    return matrix
  • np.zeros((n, n)) 创建n×n零矩阵
  • 通过双重循环构造对称矩阵
  • 实际应用中需要根据专家判断填写具体数值

2. 权重计算

def calculate_weights(matrix):
    """计算权重向量"""
    n = matrix.shape[0]
    normalized = matrix / matrix.sum(axis=1, keepdims=True)
    weights = normalized.mean(axis=1)
    return weights
  • matrix.sum(axis=1, keepdims=True) 保持维度，确保除法正确
  • mean(axis=1) 计算行平均值作为权重
  • 可通过np.round(weights, 4)控制小数位数

3. 一致性检验

def calculate_consistency_ratio(matrix):
    """计算一致性比率"""
    n = matrix.shape[0]
    eigen_values, eigen_vectors = linalg.eig(matrix)
    max_eigen = np.max(eigen_values)
    ci = (max_eigen - n) / (n - 1)
    RI_table = {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}
    ri = RI_table[n]
    cr = ci / ri if ri != 0 else 0
    return cr
  • linalg.eig 返回特征值和特征向量
  • np.max(eigen_values) 获取最大特征值
  • RI_table 需要根据矩阵阶数查表

七、进阶使用

1. 动态权重调整

def update_weights(matrix, criteria):
    """动态更新权重"""
    weights = calculate_weights(matrix)
    # 归一化处理
    weights = weights / weights.sum()
    return weights

2. 多层次结构处理

def build_hierarchical_model(criteria, sub_criteria, sub_weights):
    """构建多层次模型"""
    total_weights = []
    for i, criterion in enumerate(criteria):
        sub_weights_i = sub_weights[i]
        # 计算该准则的综合权重
        total_weight = np.dot(sub_weights_i, weights)
        total_weights.append(total_weight)
    return total_weights

3. 结果可视化

import matplotlib.pyplot as plt

def plot_results(scores):
    """绘制结果可视化"""
    plt.bar(range(len(scores)), list(scores.values()), align='center')
    plt.xticks(range(len(scores)), list(scores.keys()))
    plt.ylabel('Score')
    plt.title('City Scores')
    plt.show()

八、性能与工程实践

1. 性能优化

对于大规模数据，建议使用NumPy进行向量化计算：

def optimized_weights(matrix):
    """优化版权重计算"""
    return np.sum(matrix, axis=1) / np.sum(matrix, axis=1, keepdims=True)

2. 异常处理

def safe_calculate_weights(matrix):
    """安全版权重计算"""
    if np.any(np.isnan(matrix)):
        raise ValueError("矩阵包含NaN值")
    if np.any(np.isinf(matrix)):
        raise ValueError("矩阵包含无穷大")
    return calculate_weights(matrix)

3. 安全考虑

  • 输入验证：确保输入矩阵为正矩阵
  • 数据清洗：处理异常值和缺失值
  • 权重归一化：防止数值溢出

九、常见问题与踩坑

1. 判断矩阵不一致

错误示例：

# 错误的判断矩阵
matrix = np.array([
    [1, 3, 5],
    [1/3, 1, 3],
    [1/5, 1/3, 1]
])

问题分析：

  • 上述矩阵不满足对称性
  • 需要满足互反性：ai = 1/aj

改进方案：

def validate_matrix(matrix):
    """验证矩阵对称性"""
    if not np.allclose(matrix, 1 / matrix.T):
        raise ValueError("判断矩阵不满足互反性")

2. 权重计算错误

错误示例：

# 错误的权重计算
weights = matrix.sum(axis=0) / matrix.sum()

问题分析：

  • 错误地使用了列求和而不是行求和

改进方案：

weights = matrix.sum(axis=1) / matrix.sum(axis=1, keepdims=True)

3. 一致性检验错误

错误示例：

# 错误的RI值查找
ri = 0.58  # 错误地使用3阶矩阵的RI值

改进方案：

RI_table = {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}
ri = RI_table[len(matrix)]

十、最佳实践

  1. 多层结构设计：建议采用3-5层结构，避免层次过深
  2. 专家参与：关键指标的判断矩阵应由领域专家共同确定
  3. 结果解释：需对权重结果进行合理解释，避免机械使用
  4. 定期校验：当指标发生变化时，应重新进行一致性检验
  5. 结果可视化：使用图表展示结果，便于决策者理解

十一、总结

层次分析法（AHP）作为一种多准则决策方法，在复杂决策问题中具有独特优势。本文通过三个代码示例和一个完整案例，深入解析了AHP的实现原理和实际应用。在实现过程中需要注意判断矩阵的构造、权重计算和一致性检验等关键环节。

AHP方法适用于需要量化多维度决策的场景，但不适合实时计算或数据量大的情况。在实际项目中，应结合具体业务需求进行调整，同时注意输入验证和结果解释。通过合理的权重计算和一致性检验，可以确保决策结果的科学性和可靠性。

对于开发人员而言，建议使用NumPy进行高效计算，并通过可视化工具展示结果。在处理大规模数据时，可以考虑使用分布式计算框架进行优化。最终，AHP的实践效果取决于对业务场景的准确理解和对算法原理的深入掌握。

python
最后修改于：2026年09月27日 05:05

评论已关闭

推荐阅读

AIGC实战——Transformer模型
2024年12月01日
python , AI , 机器学习
Socket TCP 和 UDP 编程基础（Python）
2024年11月30日
python , tcp , udp
如何使用 ChatGPT 进行学术润色？你需要这些指令
2024年12月01日
AI
最新 Python 调用 OpenAi 详细教程实现问答、图像合成、图像理解、语音合成、语音识别（详细教程）
2024年11月24日
python , AI
ChatGPT 和 DALL·E 2 配合生成故事绘本
2024年12月01日
python , AI
omegaconf，一个超强的 Python 库！
2024年11月24日
python
【视觉AIGC识别】误差特征、人脸伪造检测、其他类型假图检测
2024年12月01日
python , AI
［超级详细］如何在深度学习训练模型过程中使用 GPU 加速
2024年11月29日
python , AI , 机器学习
Python 物理引擎pymunk最完整教程
2024年11月27日
python
MediaPipe 人体姿态与手指关键点检测教程
2024年11月27日
python
深入了解 Taipy：Python 打造 Web 应用的全面教程
2024年11月26日
python
基于Transformer的时间序列预测模型
2024年11月25日
python , Matplotlib , 机器学习
Python在金融大数据分析中的AI应用（股价分析、量化交易）实战
2024年11月25日
python , Matplotlib , 机器学习
AIGC Gradio系列学习教程之Components
2024年12月01日
python , AI
Python3 `asyncio` — 异步 I/O，事件循环和并发工具
2024年11月30日
python
llama-factory SFT系列教程：大模型在自定义数据集 LoRA 训练与部署
2024年12月01日
python , AI , 机器学习
Python 多线程和多进程用法
2024年11月24日
python
Python socket详解，全网最全教程
2024年11月27日
python , http , websocket
python之plot()和subplot()画图
2024年11月26日
python , Matplotlib
理解 DALL·E 2、Stable Diffusion 和 Midjourney 工作原理
2024年12月01日
python , AI , 机器学习
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号