Gibt es eine Bibliotheksfunktion für Root Mean Square Error (RMSE) in Python?

Ich weiß, dass ich eine quadratische Fehlerfunktion wie folgt implementieren könnte:

def rmse(predictions, targets):
    return np.sqrt(((predictions - targets) ** 2).mean())

Was suche ich, wenn diese rmse-Funktion irgendwo in einer Bibliothek implementiert ist, vielleicht in scipy oder scikit-learn?

sklearn.metricshat eine mean_squared_errorFunktion. Der RMSE ist nur die Quadratwurzel dessen, was er zurückgibt.

from sklearn.metrics import mean_squared_error
from math import sqrt

rms = sqrt(mean_squared_error(y_actual, y_predicted))

Was ist RMSE? Auch als MSE, RMD oder RMS bekannt. Welches Problem löst es?

Wenn Sie RMSE: (mittlerer quadratischer Fehler), MSE: (mittlerer quadratischer Fehler) RMD (mittlere quadratische Abweichung) und RMS: (quadratischer Mittelwert) verstehen, ist es unnötig, nach einer Bibliothek zu fragen, um dies für Sie zu berechnen . Alle diese Metriken sind eine einzelne Zeile Python-Code, die höchstens 5 cm lang ist. Die drei Metriken rmse, mse, rmd und rms sind im Kern konzeptionell identisch.

RMSE beantwortet die Frage: „Wie ähnlich ist , im Durchschnitt sind die Zahlen in list1zu list2?“. Die beiden Listen müssen gleich groß sein. Ich möchte "das Rauschen zwischen zwei beliebigen Elementen auswaschen, die Größe der gesammelten Daten auswaschen und ein Gefühl für eine Veränderung im Laufe der Zeit mit einer einzigen Zahl bekommen".

Intuition und ELI5 für RMSE:

Stellen Sie sich vor, Sie lernen, Pfeile auf eine Dartscheibe zu werfen. Jeden Tag üben Sie eine Stunde lang. Sie möchten herausfinden, ob es Ihnen besser oder schlechter geht. Sie machen also jeden Tag 10 Würfe und messen den Abstand zwischen dem Bullauge und der Stelle, an der Ihr Pfeil getroffen hat.

Sie erstellen eine Liste dieser Nummern list1. Verwenden Sie den quadratischen Mittelwertfehler zwischen den Abständen am Tag 1 und a list2, der alle Nullen enthält. Machen Sie dasselbe am 2. und n. Tag. Was Sie erhalten, ist eine einzelne Zahl, die hoffentlich mit der Zeit abnimmt. Wenn Ihre RMSE-Nummer Null ist, schlagen Sie jedes Mal Bullseyes. Wenn die rmse-Nummer steigt, werden Sie schlechter.

Beispiel für die Berechnung des quadratischen Mittelwertfehlers in Python:

import numpy as np
d = [0.000, 0.166, 0.333]   #ideal target distances, these can be all zeros.
p = [0.000, 0.254, 0.998]   #your performance goes here

print("d is: " + str(["%.8f" % elem for elem in d]))
print("p is: " + str(["%.8f" % elem for elem in p]))

def rmse(predictions, targets):
    return np.sqrt(((predictions - targets) ** 2).mean())

rmse_val = rmse(np.array(d), np.array(p))
print("rms error is: " + str(rmse_val))

Welche Drucke:

d is: ['0.00000000', '0.16600000', '0.33300000']
p is: ['0.00000000', '0.25400000', '0.99800000']
rms error between lists d and p is: 0.387284994115

Die mathematische Notation:

Glyphenlegende: n ist eine ganz positive ganze Zahl, die die Anzahl der Würfe darstellt. istellt einen ganzen positiven Ganzzahlzähler dar, der die Summe auflistet. dsteht für die idealen Abstände, die list2im obigen Beispiel alle Nullen enthalten. psteht für Leistung, die list1im obigen Beispiel steht. hochgestellt 2 steht für numerisches Quadrat. d _i ist der _i- te Index von d. p _i ist der _i- te Index von p.

Die rmse erfolgt in kleinen Schritten, damit es verstanden werden kann:

def rmse(predictions, targets):

    differences = predictions - targets                       #the DIFFERENCEs.

    differences_squared = differences ** 2                    #the SQUAREs of ^

    mean_of_differences_squared = differences_squared.mean()  #the MEAN of ^

    rmse_val = np.sqrt(mean_of_differences_squared)           #ROOT of ^

    return rmse_val                                           #get the ^

Wie funktioniert jeder Schritt von RMSE:

Wenn Sie eine Zahl von einer anderen subtrahieren, erhalten Sie den Abstand zwischen ihnen.

8 - 5 = 3         #absolute distance between 8 and 5 is +3
-20 - 10 = -30    #absolute distance between -20 and 10 is +30

Wenn Sie eine beliebige Anzahl selbst multiplizieren, ist das Ergebnis immer positiv, da negativ mal negativ positiv ist:

3*3     = 9   = positive
-30*-30 = 900 = positive

Addieren Sie sie alle, aber warten Sie, dann würde ein Array mit vielen Elementen einen größeren Fehler aufweisen als ein kleines Array. Mitteln Sie sie also nach der Anzahl der Elemente.

Aber warte, wir haben sie alle früher quadriert, um sie positiv zu erzwingen. Machen Sie den Schaden mit einer Quadratwurzel rückgängig!

Sie erhalten also eine einzelne Zahl, die im Durchschnitt den Abstand zwischen jedem Wert von list1 und dem entsprechenden Elementwert von list2 darstellt.

Wenn der RMSE-Wert mit der Zeit sinkt, freuen wir uns, dass die Varianz abnimmt.

RMSE ist nicht die genaueste Strategie zur Linienanpassung. Die kleinsten Quadrate sind:

Der quadratische Mittelwertfehler misst den vertikalen Abstand zwischen dem Punkt und der Linie. Wenn Ihre Daten also wie eine Banane geformt sind, flach in der Nähe des Bodens und steil in der Nähe des oberen Bereichs, meldet der RMSE größere Abstände zu hohen Punkten, aber kurze Abstände zu Punkte niedrig, wenn tatsächlich die Abstände gleich sind. Dies führt zu einem Versatz, bei dem die Linie lieber näher an hohen als an niedrigen Punkten liegt.

Wenn dies ein Problem ist, behebt die Methode der kleinsten Quadrate dies: https://mubaris.com/posts/linear-regression

Fallstricke, die diese RMSE-Funktion unterbrechen können:

Wenn eine der Eingabelisten Nullen oder Unendlichkeiten enthält, ist der rmse-Ausgabewert nicht sinnvoll. Es gibt drei Strategien, um mit Nullen / fehlenden Werten / Unendlichkeiten in beiden Listen umzugehen: Ignorieren Sie diese Komponente, setzen Sie sie auf Null oder fügen Sie allen Zeitschritten eine bestmögliche Schätzung oder ein einheitliches zufälliges Rauschen hinzu. Jedes Mittel hat seine Vor- und Nachteile, je nachdem, was Ihre Daten bedeuten. Im Allgemeinen wird das Ignorieren von Komponenten mit einem fehlenden Wert bevorzugt. Dies führt jedoch dazu, dass der RMSE gegen Null geht, sodass Sie glauben, dass sich die Leistung verbessert hat, wenn dies nicht der Fall ist. Das Hinzufügen von zufälligem Rauschen nach bestem Wissen könnte bevorzugt werden, wenn viele Werte fehlen.

Um die relative Korrektheit der RMSE-Ausgabe zu gewährleisten, müssen Sie alle Nullen / Unendlichkeiten aus der Eingabe entfernen.

RMSE hat keine Toleranz für Ausreißerdatenpunkte, die nicht dazu gehören

Fehlerquadrate des quadratischen Mittelwerts hängen davon ab, dass alle Daten richtig sind und alle als gleich gezählt werden. Das bedeutet, dass ein Streupunkt, der weit draußen im linken Feld liegt, die gesamte Berechnung völlig ruinieren wird. Informationen zum Umgang mit Ausreißerdatenpunkten und zum Entlassen ihres enormen Einflusses nach einem bestimmten Schwellenwert finden Sie unter Robuste Schätzer, die einen Schwellenwert für das Entlassen von Ausreißern festlegen.

Das ist wahrscheinlich schneller?:

n = len(predictions)
rmse = np.linalg.norm(predictions - targets) / np.sqrt(n)

In scikit-learn 0.22.0 können Sie mean_squared_error()das Argument übergeben squared=False, um den RMSE zurückzugeben.

from sklearn.metrics import mean_squared_error

mean_squared_error(y_actual, y_predicted, squared=False)

Nur für den Fall, dass jemand diesen Thread im Jahr 2019 findet, gibt es eine Bibliothek namens, ml_metricsdie ohne Vorinstallation in Kaggles Kerneln verfügbar ist, ziemlich leichtgewichtig und zugänglich über pypi(sie kann einfach und schnell mit installiert werden pip install ml_metrics):

from ml_metrics import rmse
rmse(actual=[0, 1, 2], predicted=[1, 10, 5])
# 5.507570547286102

Es gibt nur wenige andere interessante Metriken, die nicht verfügbar sind sklearn, wie z mapk.

Verweise:

• https://pypi.org/project/ml_metrics/
• https://github.com/benhamner/Metrics/tree/master/Python

Eigentlich habe ich einige davon als Dienstprogrammfunktionen für Statistikmodelle geschrieben

http://statsmodels.sourceforge.net/devel/tools.html#measure-for-fit-performance-eval-measures

und http://statsmodels.sourceforge.net/devel/generated/statsmodels.tools.eval_measures.rmse.html#statsmodels.tools.eval_measures.rmse

Meistens ein oder zwei Liner und nicht viel Eingabeprüfung, und hauptsächlich dazu gedacht, beim Vergleich von Arrays leicht Statistiken zu erhalten. Aber sie haben Unit-Tests für die Achsenargumente, weil ich dort manchmal schlampige Fehler mache.

Oder indem Sie einfach nur NumPy-Funktionen verwenden:

def rmse(y, y_pred):
    return np.sqrt(np.mean(np.square(y - y_pred)))

Wo:

• y ist mein Ziel
• y_pred ist meine Vorhersage

Beachten Sie dies rmse(y, y_pred)==rmse(y_pred, y)aufgrund der quadratischen Funktion.

Sie können die RMSE-Funktion nicht direkt in SKLearn finden. Anstatt sqrt manuell auszuführen, gibt es eine andere Standardmethode für die Verwendung von sklearn. Anscheinend enthält Sklearns mean_squared_error selbst einen Parameter namens "squared" mit dem Standardwert true. Wenn wir ihn auf false setzen, gibt dieselbe Funktion RMSE anstelle von MSE zurück.

# code changes implemented by Esha Prakash
from sklearn.metrics import mean_squared_error
rmse = mean_squared_error(y_true, y_pred , squared=False)

Hier ist ein Beispielcode, der den RMSE zwischen zwei Polygondateiformaten berechnet PLY. Es verwendet sowohl die ml_metricslib als auch die np.linalg.norm:

import sys
import SimpleITK as sitk
from pyntcloud import PyntCloud as pc
import numpy as np
from ml_metrics import rmse

if len(sys.argv) < 3 or sys.argv[1] == "-h" or sys.argv[1] == "--help":
    print("Usage: compute-rmse.py <input1.ply> <input2.ply>")
    sys.exit(1)

def verify_rmse(a, b):
    n = len(a)
    return np.linalg.norm(np.array(b) - np.array(a)) / np.sqrt(n)

def compare(a, b):
    m = pc.from_file(a).points
    n = pc.from_file(b).points
    m = [ tuple(m.x), tuple(m.y), tuple(m.z) ]; m = m[0]
    n = [ tuple(n.x), tuple(n.y), tuple(n.z) ]; n = n[0]
    v1, v2 = verify_rmse(m, n), rmse(m,n)
    print(v1, v2)

compare(sys.argv[1], sys.argv[2])

1. Nein, es gibt eine Bibliothek Scikit Learn für maschinelles Lernen, die mithilfe der Python-Sprache problemlos verwendet werden kann. Es hat die Funktion für Mean Squared Error, die ich über den folgenden Link teile:

https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html

2. Die Funktion heißt mean_squared_error (siehe unten), wobei y_true echte Klassenwerte für die Datentupel und y_pred die vorhergesagten Werte sind, die von dem von Ihnen verwendeten Algorithmus für maschinelles Lernen vorhergesagt werden:

mean_squared_error (y_true, y_pred)

3. Sie müssen es ändern, um RMSE zu erhalten (mithilfe der sqrt-Funktion mit Python). Dieser Vorgang wird unter folgendem Link beschrieben: https://www.codeastar.com/regression-model-rmsd/

Der endgültige Code wäre also ungefähr so:

aus sklearn.metrics importiere mean_squared_error aus math importiere sqrt

RMSD = sqrt (mean_squared_error (testing_y, Vorhersage))

Drucken (RMSD)