Existe-t-il une fonction de bibliothèque pour l'erreur quadratique moyenne (RMSE) en python?

Je sais que je pourrais implémenter une fonction d'erreur quadratique moyenne comme celle-ci:

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

Qu'est-ce que je recherche si cette fonction rmse est implémentée dans une bibliothèque quelque part, peut-être dans scipy ou scikit-learn?

sklearn.metricsa une mean_squared_errorfonction. Le RMSE n'est que la racine carrée de tout ce qu'il renvoie.

from sklearn.metrics import mean_squared_error
from math import sqrt

rms = sqrt(mean_squared_error(y_actual, y_predicted))

Qu'est-ce que RMSE? Aussi connu sous le nom de MSE, RMD ou RMS. Quel problème résout-il?

Si vous comprenez RMSE: (erreur quadratique moyenne), MSE: (erreur quadratique moyenne) RMD (écart quadratique moyen) et RMS: (moyenne quadratique quadratique), alors demander une bibliothèque pour calculer cela pour vous est inutile sur-ingénierie . Toutes ces métriques sont une seule ligne de code python d'au plus 2 pouces de long. Les trois métriques rmse, mse, rmd et rms sont fondamentalement identiques sur le plan conceptuel.

RMSE répond à la question: « Comment similaires, en moyenne, sont les nombres list1à list2? ». Les deux listes doivent être de la même taille. Je veux "effacer le bruit entre deux éléments donnés, effacer la taille des données collectées et avoir une impression de nombre unique pour le changement au fil du temps".

Intuition et ELI5 pour RMSE:

Imaginez que vous apprenez à lancer des fléchettes sur un jeu de fléchettes. Chaque jour, vous pratiquez pendant une heure. Vous voulez savoir si vous vous améliorez ou si vous empirez. Ainsi, chaque jour, vous effectuez 10 lancers et mesurez la distance entre la cible et l'endroit où votre fléchette a frappé.

Vous faites une liste de ces chiffres list1. Utilisez l'erreur quadratique moyenne entre les distances au jour 1 et a list2contenant tous les zéros. Faites de même le 2ème et le nième jour. Ce que vous obtiendrez est un chiffre unique qui, espérons-le, diminuera avec le temps. Lorsque votre numéro RMSE est égal à zéro, vous touchez à chaque fois des bullsey. Si le nombre RMSE augmente, vous vous empirez.

Exemple de calcul de l'erreur quadratique moyenne racine en 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))

Quelles impressions:

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

La notation mathématique:

Légende des glyphes: n est un entier positif représentant le nombre de lancers. ireprésente un compteur entier positif qui énumère la somme. dreprésente les distances idéales, le list2contenant tous les zéros dans l'exemple ci-dessus. preprésente la performance, list1dans l'exemple ci-dessus. exposant 2 signifie numérique au carré. d _i est le ième indice de d. p _i est le i'ième indice de p.

Le rmse fait par petites étapes pour qu'il puisse être compris:

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 ^

Comment fonctionne chaque étape de RMSE:

Soustraire un nombre d'un autre vous donne la distance qui les sépare.

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

Si vous multipliez un nombre par lui-même, le résultat est toujours positif car le nombre négatif multiplié par le négatif est positif:

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

Ajoutez-les tous, mais attendez, alors un tableau avec de nombreux éléments aurait une erreur plus grande qu'un petit tableau, alors faites la moyenne par le nombre d'éléments.

Mais attendez, nous les avons tous mis au carré plus tôt pour les forcer à être positifs. Annulez les dégâts avec une racine carrée!

Cela vous laisse un nombre unique qui représente, en moyenne, la distance entre chaque valeur de list1 et sa valeur d'élément correspondante de list2.

Si la valeur RMSE diminue avec le temps, nous sommes satisfaits car la variance diminue.

RMSE n'est pas la stratégie d'ajustement de ligne la plus précise, le total des moindres carrés est:

L'erreur quadratique moyenne mesure la distance verticale entre le point et la ligne, donc si vos données ont la forme d'une banane, plates près du bas et raides près du sommet, alors le RMSE rapportera des distances plus grandes aux points hauts, mais des distances courtes à points bas alors qu'en fait les distances sont équivalentes. Cela provoque un biais où la ligne préfère être plus proche des points hauts que bas.

S'il s'agit d'un problème, la méthode des moindres carrés du total corrige ceci: https://mubaris.com/posts/linear-regression

Gotchas qui peuvent casser cette fonction RMSE:

S'il y a des valeurs nulles ou infinies dans l'une ou l'autre des listes d'entrée, la valeur rmse de sortie n'aura pas de sens. Il existe trois stratégies pour gérer les valeurs nulles / les valeurs manquantes / les infinis dans l'une ou l'autre des listes: ignorer ce composant, le remettre à zéro ou ajouter une meilleure estimation ou un bruit aléatoire uniforme à tous les pas de temps. Chaque remède a ses avantages et ses inconvénients en fonction de la signification de vos données. En général, il est préférable d'ignorer tout composant avec une valeur manquante, mais cela biaise le RMSE vers zéro, ce qui vous fait penser que les performances se sont améliorées alors qu'elles ne l'ont pas vraiment été. L'ajout d'un bruit aléatoire sur une meilleure estimation pourrait être préférable s'il y a beaucoup de valeurs manquantes.

Afin de garantir l'exactitude relative de la sortie RMSE, vous devez éliminer toutes les valeurs nulles / infinies de l'entrée.

RMSE a une tolérance zéro pour les points de données aberrants qui n'appartiennent pas

Les carrés d'erreur quadratique moyenne reposent sur le fait que toutes les données sont exactes et toutes sont comptées comme égales. Cela signifie qu'un point errant qui se trouve dans le champ gauche va totalement ruiner tout le calcul. Pour gérer les points de données aberrants et ignorer leur énorme influence après un certain seuil, consultez Estimateurs robustes qui intègrent un seuil de rejet des valeurs aberrantes.

C'est probablement plus rapide?:

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

Dans scikit-learn 0.22.0, vous pouvez passer mean_squared_error()l'argument squared=Falsepour renvoyer le RMSE.

from sklearn.metrics import mean_squared_error

mean_squared_error(y_actual, y_predicted, squared=False)

Juste au cas où quelqu'un trouverait ce fil en 2019, il existe une bibliothèque appelée ml_metricsqui est disponible sans pré-installation dans les noyaux de Kaggle, assez allégée et accessible via pypi(elle peut être installée facilement et rapidement avec pip install ml_metrics):

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

Il a quelques autres métriques intéressantes qui ne sont pas disponibles dans sklearn, comme mapk.

Références:

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

En fait, j'ai écrit un tas de ceux-ci en tant que fonctions utilitaires pour statsmodels

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

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

Surtout un ou deux liners et peu de vérification d'entrée, et principalement destiné à obtenir facilement des statistiques lors de la comparaison de tableaux. Mais ils ont des tests unitaires pour les arguments de l'axe, car c'est là que je fais parfois des erreurs bâclées.

Ou simplement en utilisant uniquement les fonctions NumPy:

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

Où:

• y est ma cible
• y_pred est ma prédiction

Notez qu'en rmse(y, y_pred)==rmse(y_pred, y)raison de la fonction carrée.

Vous ne pouvez pas trouver la fonction RMSE directement dans SKLearn. Mais, au lieu de faire manuellement sqrt, il existe un autre moyen standard d'utiliser sklearn. Apparemment, mean_squared_error de Sklearn contient lui-même un paramètre appelé "squared" avec la valeur par défaut true. Si nous le définissons sur false, la même fonction retournera RMSE au lieu de MSE.

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

Voici un exemple de code qui calcule le RMSE entre deux formats de fichier de polygone PLY. Il utilise à la fois la ml_metricslib et le 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. Non, il existe une bibliothèque Scikit Learn pour l'apprentissage automatique et elle peut être facilement utilisée en utilisant le langage Python. Il a une fonction pour l'erreur quadratique moyenne dont je partage le lien ci-dessous:

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

2. La fonction est nommée mean_squared_error comme indiqué ci-dessous, où y_true serait des valeurs de classe réelles pour les tuples de données et y_pred serait les valeurs prédites, prédites par l'algorithme d'apprentissage automatique que vous utilisez:

mean_squared_error (y_true, y_pred)

3. Vous devez le modifier pour obtenir RMSE (en utilisant la fonction sqrt en utilisant Python). Ce processus est décrit dans ce lien: https://www.codeastar.com/regression-model-rmsd/

Ainsi, le code final serait quelque chose comme:

depuis sklearn.metrics importation mean_squared_error depuis importation mathématique sqrt

RMSD = sqrt (mean_squared_error (testing_y, prediction))

imprimer (RMSD)