python极差转换法代码

极差转换法（Min-Max Scaling）是一种常用的数据归一化方法，用于将数据缩放到指定的范围内。在Python中，可以使用以下代码实现极差转换法：

def min_max_scaling(data, min_val, max_val):
    min_data = min(data)
    max_data = max(data)
    scaled_data = []
    for val in data:
        scaled_val = (val - min_data) / (max_data - min_data) * (max_val - min_val) + min_val
        scaled_data.append(scaled_val)
    return scaled_data

其中，`data`是待转换的数据列表，`min_val`和`max_val`是转换后的数据范围。函数会遍历数据列表，对每个值进行转换，并将转换后的值添加到`scaled_data`列表中。最后，返回转换后的数据列表。

使用示例：

data = [1, 2, 3, 4, 5]
scaled_data = min_max_scaling(data, 0, 1)
print(scaled_data)

输出结果：

[0.0, 0.25, 0.5, 0.75, 1.0]

相关问题

怎么用python极差法对数据进行归一化处理的无量纲处理

极差法是一种常见的归一化处理方法，可以将数据转换为无量纲的形式，使得不同量级的数据可以在同一尺度下进行比较。在Python中，可以使用以下代码实现极差法归一化处理：

import numpy as np

# 极差法归一化处理函数
def rangeNormalization(data):
    # 计算数据的极差
    r = np.max(data) - np.min(data)
    # 对数据进行归一化处理
    newData = (data - np.min(data)) / r
    return newData

其中，`data`是需要进行归一化处理的数据。函数中首先计算数据的极差`r`，然后用每个数据值减去最小值，再除以极差，即可完成归一化处理。函数返回归一化后的数据`newData`。

例如，假设有一组数据`data = [1, 2, 3, 4, 5]`，可以使用以上代码进行极差法归一化处理：

data = [1, 2, 3, 4, 5]
newData = rangeNormalization(data)
print(newData)

输出结果为：

[0.   0.25 0.5  0.75 1.  ]

可以看到，归一化后的数据均在0到1之间，达到了无量纲处理的目的。

极差标准化r熵权法分配权重代码

### 极差标准化与熵权法分配权重

#### 极差标准化
极差标准化是一种常见的数据预处理方法，用于将不同量纲的数据转换到同一尺度下以便比较。对于给定的一组数据 \(X\) ，其极差标准化后的值 \(X'\) 可通过如下公式计算：

\[ X' = \frac{X - \min(X)} \]

此过程确保所有特征具有相同的范围，通常为 [0, 1]。

import numpy as np

def min_max_normalization(data):
    """ 对数据进行极差标准化 """
    max_data = np.max(data, axis=0)
    min_data = np.min(data, axis=0)
    normalized_data = (data - min_data) / (max_data - min_data)
    return normalized_data

#### 熵权法分配权重
熵权法基于信息论中的熵概念来衡量不确定性程度，并据此确定各个评价指标的重要性系数（即权重）。具体步骤包括但不限于求解每项指标的信息熵、计算冗余度并最终得出相应权重[^2]。

function weights = entropy_weight_method(matrix)
% 输入参数 matrix 是 n*m 的矩阵，n 行代表样本数，m 列表示属性数量
    
    % 计算概率分布 p_ij
    sum_matrix = sum(matrix);
    pij = bsxfun(@rdivide,matrix,sum_matrix);

    % 防止 log 函数内部出现负无穷大情况
    epsilon = eps;
    pij(pij == 0) = epsilon;

    % 计算第 j 属性下的熵 e_j
    ej = -sum((pij .* log(pij))') ./ log(size(matrix,1));

    % 计算冗余度 g_j 和 权重 w_j
    gj = 1 - ej;
    weights = gj ./ sum(gj);
end

import numpy as np

def entropy_weight_method(data):
    """ 使用熵权法计算各列的权重 """
    
    # 归一化操作
    prob = data / np.sum(data, axis=0)

    # 添加一个小常数防止log(0)，这里采用numpy默认最小浮点精度
    k = 1.0 / np.log(prob.shape[0])
    E = k * np.nansum(-prob * np.log(prob), axis=0)

    # 计算冗余度和权重
    redundancy = 1 - E
    weight = redundancy / np.sum(redundancy)

    return weight