python熵权topsis法代码

### 回答1：
Python语言可以使用熵权TOPSIS法来进行多属性决策分析。下面是一个简单的代码示例：

import numpy as np

def topsis(data, weights, is_maximize):
    # 数据规范化
    normalized_data = data / np.sqrt(np.sum(data ** 2, axis=0))
    
    # 权重归一化
    normalized_weights = weights / np.sum(weights)
    
    # 计算加权规范化矩阵
    weighted_normalized_data = normalized_data * normalized_weights
    
    # 计算正理想解和负理想解
    if is_maximize:
        ideal_best = np.max(weighted_normalized_data, axis=0)
        ideal_worst = np.min(weighted_normalized_data, axis=0)
    else:
        ideal_best = np.min(weighted_normalized_data, axis=0)
        ideal_worst = np.max(weighted_normalized_data, axis=0)
    
    # 计算到正理想解和负理想解的距离
    distance_to_best = np.sqrt(np.sum((weighted_normalized_data - ideal_best) ** 2, axis=1))
    distance_to_worst = np.sqrt(np.sum((weighted_normalized_data - ideal_worst) ** 2, axis=1))
    
    # 计算综合评价指数
    topsis_score = distance_to_worst / (distance_to_best + distance_to_worst)
    
    return topsis_score

# 示例数据
data = np.array([[3, 4, 6, 8],
                 [2, 7, 1, 9],
                 [5, 6, 4, 7]])

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

# 使用熵权TOPSIS法进行多属性决策分析
result = topsis(data, weights, True)

print(result)

以上代码实现了使用熵权TOPSIS法进行多属性决策分析。输入数据是一个二维数组，每列代表一个属性，每行代表一个决策对象。weights是每个属性的权重，is_maximize表示是否最大化指标。函数返回一个一维数组，表示每个决策对象的综合评价指数。运行代码后，打印结果即为各个决策对象的综合评价指数。

### 回答2：
熵权TOPSIS法是一种多属性决策方法，用来评估各个方案的综合指标。以下是使用Python编写的熵权TOPSIS法代码示例：

import numpy as np

def entropy_weight(data):
    # 计算熵权向量
    m, n = data.shape
    p = data.copy()  # 创建一个与data相同的矩阵p
    for j in range(n):
        p[:, j] = p[:, j] / np.sum(p[:, j])  # 归一化
    ent = (-1 / np.log(m)) * np.nansum(p * np.log(p), axis=0)  # 计算每个属性的熵
    weight = (1 - ent) / np.sum(1 - ent)  # 计算每个属性的权重
    return weight

def topsis_method(data, weight, positive_indicator):
    # TOPSIS法计算综合评价结果
    m, n = data.shape
    s = data * weight  # 加权后的决策矩阵
    ideal_best = np.max(s, axis=0)  # 理想最佳方案
    ideal_worst = np.min(s, axis=0)  # 理想最差方案
    
    # 计算到理想最佳方案的距离
    d_best = np.sqrt(np.sum((s - ideal_best) ** 2, axis=1))
    # 计算到理想最差方案的距离
    d_worst = np.sqrt(np.sum((s - ideal_worst) ** 2, axis=1))
    
    # 计算综合评价得分
    score = d_worst / (d_best + d_worst)
    if positive_indicator == -1:
        score = 1 - score  # 如果指标为负指标，则将得分反转
    
    return score

# 示例数据
data = np.array([[1, 5, 3, 2],
                 [2, 4, 5, 3],
                 [5, 4, 3, 1],
                 [4, 3, 2, 2]])

weight = entropy_weight(data)
positive_indicator = -1  # -1表示第四列是负指标，可以根据实际情况更改

result = topsis_method(data, weight, positive_indicator)
print("综合评价得分：", result)

以上代码首先定义了一个计算熵权向量的函数`entropy_weight`，该函数将输入的决策矩阵归一化后计算每个属性的熵，并将熵权向量归一化得到权重。

接着定义了一个使用TOPSIS法计算综合评价结果的函数`topsis_method`，该函数根据输入的决策矩阵、权重和正/负指标，计算每个方案到理想最佳和理想最差方案的距离，并根据正/负指标计算综合评价得分。

最后，给出了一个示例数据，并使用上述函数计算了综合评价得分。最后打印出了结果。

请注意，以上代码只是一种示例实现，实际应用中可能需要根据具体情况进行适当的修改。

### 回答3：
TOPSIS（Technique for Order Preference by Similarity to Ideal Solution）是一种常用的多准则决策方法，可以用于评估多个候选方案的综合效能。Python可以使用熵权TOPSIS法进行实现。

熵权TOPSIS法的实现步骤如下：

1. 输入决策矩阵：首先，我们需要输入一个决策矩阵，其中每一行代表一个候选方案，每一列代表一个评价指标。假设决策矩阵为decision_matrix，矩阵的形状为(m, n)，其中m为候选方案的数量，n为评价指标的数量。

2. 标准化决策矩阵：将决策矩阵进行标准化处理，将每一列的数值映射到[0, 1]范围内。可以使用如下代码实现：

def normalize_matrix(decision_matrix):
    normalized_matrix = decision_matrix.copy()
    for i in range(decision_matrix.shape[1]):
        col = decision_matrix[:, i]
        min_val = np.min(col)
        max_val = np.max(col)
        normalized_matrix[:, i] = (col - min_val) / (max_val - min_val)
    return normalized_matrix

3. 计算权重矩阵：使用熵权法计算评价指标的权重。可以使用如下代码实现：

def calculate_weights(decision_matrix):
    entropy = np.zeros(decision_matrix.shape[1])
    for i in range(decision_matrix.shape[1]):
        col = decision_matrix[:, i]
        p = col / np.sum(col)
        entropy[i] = -np.sum(p * np.log2(p))
    weights = (1 - entropy) / np.sum(1 - entropy)
    return weights

4. 确定正理想解和负理想解：正理想解的每一列取对应指标的最大值，负理想解的每一列取对应指标的最小值。可以使用如下代码实现：

def determine_ideal_solutions(decision_matrix):
    positive_ideal_solution = np.max(decision_matrix, axis=0)
    negative_ideal_solution = np.min(decision_matrix, axis=0)
    return positive_ideal_solution, negative_ideal_solution

5. 计算正负理想解之间的距离：可以使用欧氏距离或曼哈顿距离等计算候选方案与正负理想解之间的距离。可以使用如下代码实现：

def calculate_distances(normalized_matrix, positive_ideal_solution, negative_ideal_solution):
    positive_distances = np.linalg.norm(normalized_matrix - positive_ideal_solution, axis=1)
    negative_distances = np.linalg.norm(normalized_matrix - negative_ideal_solution, axis=1)
    return positive_distances, negative_distances

6. 计算综合得分：根据距离计算候选方案的综合得分，综合得分越接近1表示效果越好，越接近0表示效果越差。可以使用如下代码实现：

def calculate_scores(positive_distances, negative_distances):
    scores = negative_distances / (positive_distances + negative_distances)
    return scores

以上就是熵权TOPSIS法的Python实现代码。根据以上函数，我们可以通过调用这些函数来进行熵权TOPSIS法的实际应用。