Nachfolgende gewichteter Algorithmus zum Vergleich

Question

Ich habe zwei Reihen von Zahlen ...

1) 2 2 1 0 0 1

2) 1,5 1 0 0,5 1 2

Jede Spalte wird miteinander verglichen. Niedrigere Werte sind besser. Zum Beispiel Spalte 1, Zeile 2 der Wert (1,5) ist genauer als die Zeile 1 (2)

Im Normal Vergleich würde ich auf die Summe jeder Zeile zu nehmen und zu der anderen Reihe zu vergleichen, die niedrigste Summe zu finden (genaueste). In diesem Fall würden beide gleich sein.

Ich möchte zwei andere Vergleichsmethoden erstellen Wenn die Werte aus der Spalte 1 aufsteigen sollten sie mehr gewichtet werden (Spalte 2 sollte mehr Gewicht halten als 1, 3 als 2 usw.)

Auch das Gegenteil

Ursprünglich dachte ich, es wäre am besten, den Wert durch seine Position zu teilen, aber das richtig funktioniert nicht.

Was wäre der beste Weg, dies für eine Reihe zu tun?

Danke!

Answer 1

Also alles, was Sie wirklich mit einem Gewichtungsvektor das Produkt Ihrer Matrix tun, ist zu berechnen. Siehe dieser Seite für weitere Informationen auf der Matrixmultiplikation.

d. Ihr Vektor M

M = | 2.0 2.0 1.0 0.0 0.0 1.0 |
    | 1.5 1.0 0.0 0.5 1.0 2.0 |

und in Ihrem ersten Fall die Gewichtungsvektor w:

w = (1, 1, 1, 1, 1, 1)

das Produkt von denen gibt Ihnen:

M x w = (6, 6)

, die die beiden Punkte für die beiden Reihen sind.

Für eine aufsteigende Gewichtung Verwendung so etwas wie:

w = (1, 2, 3, 4, 5, 6)

das gibt Ihnen:

M x w = (15, 22.5)

und ein absteigendes Gewicht könnten Sie entweder:

w = (6, 5, 4, 3, 2, 1)

oder

w = (1, 1/2, 1/3, 1/4, 1/5, 1/6)

(Hinweis Vektoren werden zur besseren Lesbarkeit umgesetzt).

Answer 2

Ursprünglich haben alle Werte das gleiche Gewicht, so dass Ihre Faktoren für n Werte sind alle 1 / n, so dass Ihre Summe ist:

S = 1 * v_1 + 1 * v_2 + ... + 1 * v_n

Ihr Versuch, den Wert durch seine Position zu teilen sei:

S = 1/1 * v_1 + 1/2 * v_2 + ... + 1/n * v_n

Welche noch ein gültiger Ansatz ist, sondern tut das Gegenteil von dem, was Sie wollen (Spalte 1 meiste Gewicht bekommt).

Was Sie wollen, ist so etwas wie folgt aus:

S = 1/n * v_1 + 1/n-1 * v_2 + ... + 1/1 * v_n

Sie können auch mit 1 / n + 1 starten betrachten und mit 1/2 so der letzten Wert am Ende wird ein bisschen weniger wichtig sein.

Answer 3

Ich weiß nicht, ob ich verstanden habe, was Sie tun wollen, aber vielleicht ist es diese:

for (i=0, i<length, i++)
  difference += (a[i] - b[i]) * w[i];

w [] würde ein Array mit den Gewichten von Spalte sein (z.B .: w = {1,2,3,4,5}), obwohl auch irgendein anderer Wert / Funktion sein könnte.

Also am Ende, wenn die Differenz größer als 0, a [] ist besser, und wenn es kleiner als 0 ist schlimmer.