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 racine comme ceci:
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.metrics a une fonction mean_squared_error. Le RMSE n'est que la racine carrée de tout ce qu'il retourne.
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? Également appelé MSE, RMD ou RMS. Quel problème cela résout-il?
Si vous comprenez RMSE: (erreur quadratique moyenne racine), MSE: (erreur quadratique moyenne), RMD (déviation quadratique moyenne racine) et RMS: (racine quadratique moyenne), puis demander à une bibliothèque de la calculer pour vous est une ingénierie inutile. . Toutes ces mesures constituent une seule ligne de code python d'une longueur maximale de 2 pouces. Les trois métriques rmse, mse, rmd et rms sont fondamentalement identiques sur le plan conceptuel.
RMSE répond à la question: "Dans quelle mesure, en moyenne, les nombres entre list1 et list2?". Les deux listes doivent avoir la même taille. Je veux "éliminer le bruit entre deux éléments donnés, éliminer la taille des données collectées et obtenir un nombre unique de changements 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 votre état s'aggrave. Ainsi, chaque jour, vous effectuez 10 lancers et mesurez la distance entre le point de mire et l'endroit où votre Dart a frappé.
Vous faites une liste de ces nombres list1. Utilisez l'erreur quadratique moyenne entre les distances au jour 1 et un list2 contenant tous les zéros. Faites la même chose les 2e et 3e jours. Vous obtiendrez un nombre unique qui, espérons-le, diminuera avec le temps. Lorsque votre numéro RMSE est égal à zéro, vous frappez à chaque fois Bullseyes. Si le nombre augmente, vous empirez.
Exemple de calcul de l'erreur quadratique moyenne 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. i représente un compteur entier positif entier qui énumère la somme. d représente les distances idéales, le list2 contenant tous les zéros dans l'exemple ci-dessus. p signifie performance, le list1 dans l'exemple ci-dessus. en exposant 2 correspond à un carré numérique. dje est le ième indice de d. pje est le ième indice de p.
Le rmse fait par petites étapes afin 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 à 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 n'importe quel nombre fois, le résultat est toujours positif, car les temps négatifs sont positifs:
3*3 = 9 = positive
-30*-30 = 900 = positive
Additionnez-les tous, mais attendez, alors un tableau avec de nombreux éléments aurait une erreur plus grande qu'un petit tableau, donc faites la moyenne par le nombre d'éléments.
Mais attendez, nous les avons tous confrontés plus tôt pour les forcer de manière positive. Annuler les dégâts avec une racine carrée!
Cela vous laisse avec un nombre unique qui représente, en moyenne, la distance entre chaque valeur de list1 et la valeur correspondante de list2.
Si la valeur RMSE diminue avec le temps, nous sommes satisfaits car écart diminue.
Le 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 moyenne mesure la distance verticale entre le point et la ligne. Ainsi, si vos données ont la forme d’une banane, sont plates à la base et raides au sommet, le RMSE indique alors des distances plus grandes aux points hauts, 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 haut que bas.
Si cela pose un problème, la méthode des moindres carrés résout ce problème: https://mubaris.com/posts/linear-regression
Les pièges qui peuvent casser cette fonction RMSE:
S'il y a des valeurs nulles ou infinies dans l'une ou l'autre liste d'entrée, la valeur de sortie rmse n'aura aucun sens. Il existe trois stratégies pour traiter les valeurs nulles/manquantes/infinies dans l'une ou l'autre liste: Ignorer ce composant, le mettre à 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 que ce n'était pas le cas. Il peut être préférable d’ajouter du bruit aléatoire si de nombreuses valeurs sont manquantes.
Afin de garantir l'exactitude relative de la sortie RMSE, vous devez éliminer tous les éléments nuls/infinis 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 moyens reposent sur le fait que toutes les données sont correctes et que toutes sont comptées comme égales. Cela signifie qu'un point errant dans le champ gauche va ruiner totalement le calcul. Pour gérer les points de données aberrants et rejeter leur énorme influence après un certain seuil, reportez-vous à la section Estimateurs robustes qui incluent un seuil pour le renvoi des points aberrants.
C'est probablement plus rapide ?:
n = len(predictions)
rmse = np.linalg.norm(predictions - targets) / np.sqrt(n)
Juste au cas où quelqu'un trouverait ce fil en 2019, il existe une bibliothèque appelée ml_metrics qui est disponible sans pré-installation dans les noyaux de Kaggle, très légère 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 contient peu d'autres mesures intéressantes qui ne sont pas disponibles dans sklearn, comme mapk.
Références:
En fait, j’ai écrit un tas d’entre eux comme fonctions utilitaires pour les statsmodels
http://statsmodels.sourceforge.net/devel/tools.html#measure-for-fit-performance-eval-measures
Généralement, un ou deux doublons et peu de vérification d’entrée, principalement destinés à obtenir facilement des statistiques lors de la comparaison de tableaux. Mais ils ont des tests unitaires pour les arguments d'axe, parce que c'est là que je fais parfois des erreurs négligé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 que rmse(y, y_pred)==rmse(y_pred, y) en raison de la fonction carrée.
- Non, il existe une bibliothèque Scikit Learn pour l'apprentissage automatique et elle peut être facilement utilisée en utilisant Python langue. Il a une fonction pour Mean Squared Error dont je partage le lien ci-dessous:
https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html
- La fonction est nommée mean_squared_error comme indiqué ci-dessous, où y_true serait une valeur réelle pour la classe de tuples de données et y_pred serait la valeur prédite, prédite par l'algorithme d'apprentissage automatique que vous utilisez:
mean_squared_error (y_true, y_pred)
- 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:
from sklearn.metrics import mean_squared_error de math import sqrt
RMSD = sqrt (mean_squared_error (testing_y, prédiction))
imprimer (RMSD)
Voici un exemple de code calculant le RMSE entre deux formats de fichier de polygone PLY. Il utilise à la fois le ml_metrics lib 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])