数学建模--Topsis(Python)

import numpy as np

import pandas as pd

假设有 3 个方案，每个方案有 4 个评价指标，其中前 2 个为效益型指标，后 2 个为成本型指标

原始数据（3个方案，4个指标）

data = np.array(\[

    \[80, 90, 30, 20],

    \[70, 85, 25, 15],

    \[90, 95, 35, 25]

])

指标类型（1表示效益型，0表示成本型）

indicator\_type = \[1, 1, 0, 0]

指标权重

weights = np.array(\[0.2, 0.3, 0.25, 0.25])

（三）数据标准化处理

def normalize\_data(data, indicator\_type):

    m, n = data.shape

    normalized\_data = np.zeros\_like(data, dtype=np.float64)

    for j in range(n):

        col = data\[:, j]

        max\_val = np.max(col)

        min\_val = np.min(col)

        if indicator\_type\[j] == 1:  # 效益型指标

            normalized\_data\[:, j] = (col - min\_val) / (max\_val - min\_val)

        else:  # 成本型指标

            normalized\_data\[:, j] = (max\_val - col) / (max\_val - min\_val)

    return normalized\_data

normalized\_data = normalize\_data(data, indicator\_type)

print("标准化矩阵：")

print(normalized\_data)

此函数根据指标类型对数据进行标准化，对于效益型指标，采用公式$z_{ij}=\frac{x_{ij}-{\min }_j{x}_{ij}}{{\max }_j{x}_{ij}-{\min }_j{x}_{ij}}$；对于成本型指标，采用公式$z_{ij}=\frac{{\max }_j{x}_{ij}-x_{ij}}{{\max }_j{x}_{ij}-{\min }_j{x}_{ij}}$。

（四）构建加权标准化矩阵

weighted\_normalized\_data = normalized\_data \* weights
print(weighted\_normalized\_data)

将标准化矩阵中的每个元素乘以对应的权重，得到加权标准化矩阵。

（五）确定正理想解和负理想解

\# 正理想解（每个指标取最大值）

positive\_ideal = np.max(weighted\_normalized\_data, axis=0)

\# 负理想解（每个指标取最小值）

negative\_ideal = np.min(weighted\_normalized\_data, axis=0)

print("正理想解：", positive\_ideal)

print("负理想解：", negative\_ideal)

（六）计算各方案与正、负理想解的距离

def calculate\_distance(weighted\_data, ideal):

    m, n = weighted\_data.shape

    distances = np.zeros(m)

    for i in range(m):

        distances\[i] = np.sqrt(np.sum((weighted\_data\[i, :] - ideal) \*\*2))

    return distances

d\_plus = calculate\_distance(weighted\_normalized\_data, positive\_ideal)

d\_minus = calculate\_distance(weighted\_normalized\_data, negative\_ideal)

print("与正理想解的距离：", d\_plus)

print("与负理想解的距离：", d\_minus)

采用欧氏距离公式计算各方案与正、负理想解的距离。

（七）计算相对贴近度并排序

\# 计算相对贴近度

c\_values = d\_minus / (d\_plus + d\_minus)

print("相对贴近度：", c\_values)

\# 排序（从大到小）

sorted\_indices = np.argsort(c\_values)\[::-1]

print("方案排序（从优到劣）：", sorted\_indices + 1)  # +1是因为方案编号从1开始

根据相对贴近度$C_i=\frac{d_i^{-}}{d_i^{+}+d_i^{-}}$计算值，并按照从大到小的顺序对方案进行排序