Prinzip und Python-Praxis der umfassenden Bewertungsmethode mit mehreren Indizes unter Verwendung der objektiv gewichteten Entropiewertmethode

1. Was ist die Entropiemethode?

Die Entropiemethode bezieht sich auf eine mathematische Methode zur Bestimmung des Streuungsgrades eines Indikators. Je größer die Streuung, desto größer ist der Einfluss dieses Indikators auf die Gesamtbewertung. Der Entropiewert kann verwendet werden, um den Grad der Streuung eines Indikators zu beurteilen. Die Entropiewertmethode ist eine objektive Gewichtungsmethode, die auf der Idee der Informationsentropie basiert. Sie berechnet die Informationsentropie des Indikators und bestimmt das Gewicht des Indikators basierend auf den Auswirkungen der relativen Änderung des Indikators auf das Gesamtsystem .

Die Entropiemethode ist eine häufig verwendete umfassende Bewertungsmethode mit mehreren Indizes. Sie kann die Daten mehrerer Indikatoren umfassend analysieren und ein umfassendes Bewertungsergebnis erhalten. Die Entropiemethode hat ein sehr breites Anwendungsspektrum und kann in verschiedenen Bereichen eingesetzt werden, beispielsweise in der Unternehmensführung, der Umweltbewertung, der Investitionsentscheidung usw.

Die Entropiemethode wird mit dem Analytical Hierarchy Process (AHP) verglichen, bei dem es sich um eine objektive Bewertung handelt, während es sich beim AHP um eine subjektive Bewertung handelt. Zur Bestimmung des Gewichts können neben der Entropiewertmethode auch statistische Methoden wie die Hauptkomponentenanalyse und die Faktorenanalyse eingesetzt werden. Es ist zu beachten, dass unabhängig davon, welche Methode zur Bestimmung des Gewichts verwendet wird, die tatsächliche Situation und die Art der Indikatoren umfassend berücksichtigt werden sollten und eine Sensitivitätsanalyse durchgeführt werden sollte, um festzustellen, ob das gewählte Gewicht angemessen und zuverlässig ist.

2. Grundprinzipien der Entropiemethode

In der Informationstheorie ist die Entropie ein Maß für die Unsicherheit. Je größer die Informationsmenge, desto geringer die Unsicherheit und desto kleiner die Entropie; je kleiner die Informationsmenge, desto größer die Unsicherheit und desto größer die Entropie. Basierend auf den Merkmalen der Entropie können wir die Zufälligkeit und Unordnung eines Ereignisses beurteilen, indem wir den Entropiewert berechnen. Wir können den Entropiewert auch verwenden, um den Grad der Diskretion eines Indikators zu beurteilen. Je größer der Grad der Diskretion des Indikators ist, desto größer ist der Einfluss des Indikators auf die Gesamtauswertung. Je größer der Einfluss (je größer das Gewicht, desto kleiner der Entropiewert).

Ausgestattet mit $m$ plant, evaluiert zu werden,$n$ Bewertungsindikatoren bilden die ursprüngliche Indikatordatenmatrix$X=(X_{}{)}_{m\times }$, für einen bestimmten Indikator $X_{}$, Indikatorwert $X_{}$Je größer die Differenz, desto größer ist die Rolle des Indikators in der Gesamtbewertung; sind die Indikatorwerte eines bestimmten Indikators alle gleich, spielt der Indikator in der Gesamtbewertung keine Rolle.

2.1. Datenmatrix

Mit $n$ Proben,$m$ Bewertungsindikatoren, die die ursprüngliche Datenmatrix bilden:
$A=\left(\begin{array}{ccc}{X}_{}& \dots & X_1\\ ⋮& ⋮& ⋮\\ X_n& & X_{}\end{array}\right)$

Unter diesen $X_{}ist\; der$ i$Der\; Wert\; des\; j\$-ten\; Indikators\; jedes\; Plans$ .

2.2. Datenstandardisierung und nicht-negative Verarbeitung

Da bei der Berechnung der Entropiewertmethode das Verhältnis eines bestimmten Indikators jedes Schemas zur Gesamtsumme desselben Indikatorwerts verwendet wird, gibt es keine Dimensionsauswirkungen und es besteht im Allgemeinen keine Notwendigkeit für eine Standardisierung. Wenn die Daten negative Zahlen enthalten, wird die Die Daten dürfen nicht negativ sein. Behandeln Sie sie! Um die Bedeutungslosigkeit von Logarithmen bei der Berechnung von Entropiewerten zu vermeiden, müssen außerdem Datenübersetzungen und sogar Standardisierungen durchgeführt werden.

Für positive Indikatoren:

$j_{}=\frac{X_{}-min(X_{}}{max\left(X_{}\right)-min\left(X_{}\right)}$

Für negative Indikatoren:

$j_{}=\frac{max\left(X_{}\right)-X_{}}{max\left(X_{}\right)-min\left(X_{}\right)}$

Für neutrale Indikatoren:

$j_{}=\{\begin{array}{cc}\frac{X_{}-min(X_{}}{max\left(X_{}\right)-min\left(X_{}\right)},& X_{}<bedeutenein(X\_{}_{})\\ \frac{max\left(X_{}\right)-X_{}}{max\left(X_{}\right)-min\left(X_{}\right)}& X_{}\ge bedeutenein(X\_{}_{}\end{array}$

In der obigen Formel $j_{}$Stellt die dimensionslosen Daten dar. Die dimensionslosen Daten fallen alle in $[0,1]$ Intervall,$j_{}$Je größer der Wert, desto höher das Bewertungsergebnis.

Da ein Teil der Daten nach der dimensionslosen Verarbeitung Null oder negativ ist, ist es aus Bequemlichkeitsgründen sinnlos, bei der Berechnung des Gewichts des Entropiewerts den Logarithmus zu verwenden, und die Daten müssen verarbeitet werden. Hier wird die Übersetzungsmethode übernommen.

$Z_{}=j_{}+1(ich=1,2,...m;J=1,2,...n)$

2.3. Entropieberechnung

Berechnen Sie den jjthPunktii$unter\; j\; Indikator$Der Anteil dieses Indikators unter$i\; Lösungen.$

$P_{}=\frac{Z_{}}{{\sum }_{ich=1}^{}{Z}_{}},(ich=1,2,...m;J=1,2,...n)$

Die Berechnungsformel des Entropiewerts lautet wie folgt:

$E_{}=-\frac{}{ln\left(n\right)}{\sum }_{j=1}^{}{P}_{}\ln P_{}$

Unter ihnen $P_{}$Stellt das $Der\; i-$ Faktor liegt imjjthWerte in$j\; Datenpunkten.$

Nachdem wir den Entropiewert jedes Faktors berechnet haben, können wir sein Gewicht weiter berechnen. Das Gewicht errechnet sich wie folgt:

$W_{}=\frac{1-E_{}}{{\sum }_{j=1}^{}(1-E_{})}$

Unter ihnen, $n$ stellt die Anzahl der Faktoren dar.

3. Python-Übungen

import pandas as pd
import numpy as np

# 正向指标
def set_Standard(data):
    y = (data - data.min(axis=0))/(data.max(axis=0)-data.min(axis=0))
    
    return y

def set_Standards(data, positive=None, negative=None, middle=None):
    row = data.shape[0]
    col = data.shape[1]
    data_max = data.max(axis=0)
    data_min = data.min(axis=0)
    data_mean = data.mean(axis=0)
    data_maxmin = data_max - data_min
    
    y = np.zeros((row, col),dtype='float32')
    if positive==None and negative==None and middle==None:
        # 默认为正向指标，越大越好
        y = (data - data_min)/data_maxmin
    # 正向
    if positive!=None:
        for j in positive:
            for i in range(row):
                y[i,j] = (data[i,j] - data_min[j])/data_maxmin[j]
    # 负向
    if negative!=None:
        for j in negative:
            for i in range(row):
                y[i,j] = (data_max[j] - data[i,j])/data_maxmin[j]                
    # 中性
    if middle!=None:
        do = True
        if do:
            for j in middle:
                for i in range(row):
                    if data[i,j] > data_mean[j]: 
                        y[i,j] = (data[i,j] - data_min[j])/data_maxmin[j]
                    else:               
                        data[i,j] = (data_max[j] - data[i,j])/data_maxmin[j]                
        else:
            for j in middle:
                for i in range(row):
                    y[i,j] = data[i,j]
    
    return y


# 计算熵值，得到权重
def get_weights(data, positive=None, negative=None, middle=None):
    """
    输入数据data，标准化后采用熵值法计算权重，综合得分以及排序位置
    """
    data = np.array(data)
    y = set_Standards(data, positive, negative, middle)
    #print(y)

    # 平移，避免0
    z = y + 1e-10
    #print(z)
    # 计算指标值占比
    w = z/sum(z)
    # 计算熵值
    k = 1/np.log(y.shape[0])
    e = -k*(w*np.log(w)).sum(axis=0)

    Wi = (1 - e)/sum(1 - e)
    print('weights', Wi)

    score = np.matmul(np.array(data), Wi)
    print('score', score)

    index = sorted(score, reverse=True)
    #print(index)

    # 输出名次结果
    sor = [index.index(score[l]) + 1 for l in range(len(index))]
    print('sort ',sor)

    results = {
    
    }
    results['weights'] = list(Wi)
    results['score'] = list(score)
    results['pos'] = sor
    print(results)
    
    return str(results)


if __name__ == '__main__':
    data = pd.DataFrame({
    
    '指标1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                    '指标2': [2, 4, 6, 8, 10, 2, 4, 6, 8, 10],
                    '指标3': [1, 2, 1, 3, 2, 1, 3, 2, 3, 1],
                    '指标4': [3, 1, 2, 3, 5, 8, 7, 8, 8, 9]
                   })

    df = np.array(data)
    get_weights(df, positive=[0, 1, 2], negative=[3], middle=None)

Operationsergebnis:

	weights [0.16859554 0.21985199 0.37852868 0.2330238 ]
	score [1.68589962 2.20668019 2.66947483 4.26785551 4.96367395 3.69399634
	 4.82632941 5.28912404 6.27595223 6.36021818]
	sort  [10, 9, 8, 6, 4, 7, 5, 3, 2, 1]

Referenz:

forxtz. Python umfassende Bewertung basierend auf der Entropiemethode . Blog Park. 2021.05

Yangyangcainiao. Entropiegewichtsmethode – Python . CSDN-Blog. 2022.01