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

Question

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

def rmse(prédictions, cibles):
    return np.sqrt(((prédictions - cibles) ** 2).mean())

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

Answer 1

sklearn >= 0.22.0

sklearn.metrics a une fonction mean_squared_error avec un argument squared (par défaut à True). Définir squared à False renverra le RMSE.

from sklearn.metrics import mean_squared_error

rms = mean_squared_error(y_actual, y_predicted, squared=False)

sklearn < 0.22.0

sklearn.metrics a une fonction mean_squared_error. Le RMSE est simplement la racine carrée de ce qu'il renvoie.

from sklearn.metrics import mean_squared_error
from math import sqrt

rms = sqrt(mean_squared_error(y_actual, y_predicted))

Answer 2

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 (Déviation quadratique moyenne) et RMS (Racine carrée moyenne), demander une bibliothèque pour calculer cela pour vous est une sur-ingénierie inutile. Tout cela peut être intuitivement écrit en une seule ligne de code. rmse, mse, rmd et rms sont des noms différents pour la même chose.

RMSE répond à la question : "À quel point, en moyenne, les nombres dans list1 sont-ils similaires à list2?". Les deux listes doivent être de la même taille. Éliminez le bruit entre deux éléments donnés, éliminez la taille des données collectées et obtenez un résultat numérique unique".

Intuition et ELI5 pour RMSE. Quel problème résout-il?

Imaginez que vous apprenez à lancer des fléchettes sur une cible. Chaque jour, vous pratiquez pendant une heure. Vous voulez savoir si vous vous améliorez ou si vous vous détériorez. Ainsi, chaque jour, vous lancez 10 fléchettes et mesurez la distance entre le centre et l'endroit où votre fléchette a touché.

Vous faites une liste de ces nombres list1. Utilisez l'erreur quadratique moyenne entre les distances au jour 1 et une list2 contenant tous des zéros. Faites de même les 2ème et n-ième jours. Vous obtiendrez un seul nombre qui, espérons-le, diminue avec le temps. Quand votre nombre de RMSE est zéro, vous touchez le centre à chaque fois. Si le nombre de rmse augmente, vous vous détériorez.

Exemple de calcul de l'erreur quadratique moyenne en python :

import numpy as np
d = [0.000, 0.166, 0.333]   #distances cibles idéales, celles-ci peuvent toutes être des zéros.
p = [0.000, 0.254, 0.998]   #vos performances vont ici

print("d est: " + str(["%.8f" % elem for elem in d]))
print("p est: " + 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("l'erreur rms est: " + str(rmse_val))

Qui affiche:

d est: ['0.00000000', '0.16600000', '0.33300000']
p est: ['0.00000000', '0.25400000', '0.99800000']
l'erreur rms entre les listes d et p est: 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 qui énumère la somme. d signifie les distances idéales, la list2 contenant tous les zéros dans l'exemple ci-dessus. p signifie les performances, la list1 dans l'exemple ci-dessus. Le 2 en exposant signifie carré numérique. d_i est l'indice i de d. p_i est l'indice i de p.

Le rmse fait en petites étapes pour être compris :

def rmse(predictions, targets):

    differences = predictions - targets                       #les DIFFÉRENCES.

    differences_squared = differences ** 2                    #les CARRÉs de ^

    mean_of_differences_squared = differences_squared.mean()  #la MOYENNE de ^

    rmse_val = np.sqrt(mean_of_differences_squared)           #RACINE de ^

    return rmse_val                                           #obtenez le ^

Comment fonctionne chaque étape de RMSE :

Soustraire un nombre d'un autre vous donne la distance entre eux.

8 - 5 = 3         #distance absolue entre 8 et 5 est +3
-20 - 10 = -30    #distance absolue entre -20 et 10 est +30

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

3*3     = 9   = positif
-30*-30 = 900 = positif

Les ajouter toutes ensemble, mais attendez, alors un tableau avec de nombreux éléments aurait une erreur plus grande qu'un petit tableau, donc faites la moyenne en fonction du nombre d'éléments.

Mais nous les avons tous mis au carré plus tôt, pour les forcer à être positifs. Annulez cela avec une racine carrée.

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

Si la valeur de RMSE diminue avec le temps, nous sommes satisfaits car la variance diminue. "Réduire la variance" ici est une sorte primitive d'algorithme d'apprentissage machine.

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

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 abruptes près du haut, alors l'RMSE signalera de plus grandes distances aux points hauts, mais de courtes distances aux points bas quand en fait les distances sont équivalentes. Cela entraîne un biais où la ligne préfère être plus proche des points hauts que des points bas.

Si c'est un problème, la méthode des moindres carrés totaux corrige cela : https://mubaris.com/posts/linear-regression

Pièges 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, alors la valeur rmse en sortie n'aura pas de sens. Il existe trois stratégies pour traiter les valeurs nulles / manquantes / infinies dans l'une ou l'autre des listes : Ignorer ce composant, le mettre à zéro ou ajouter une meilleure estimation ou un bruit aléatoire uniforme à tous les instants. Chaque remède a ses avantages et ses inconvénients en fonction de ce que vos données signifient. En général, ignorer tout composant avec une valeur manquante est préféré, mais cela biaise l'RMSE vers zéro en vous faisant penser que la performance s'est améliorée alors que ce n'est pas vraiment le cas. Ajouter du bruit aléatoire sur une meilleure estimation pourrait être préférable s'il y a beaucoup de valeurs manquantes.

Pour garantir la correction relative de la sortie de l'RMSE, vous devez éliminer tous les nuls / infinis de l'entrée.

RMSE n'accepte aucune tolérance pour les points de données aberrants qui ne sont pas appropriés

L'erreur quadratique moyenne repose sur le fait que toutes les données sont correctes et sont toutes comptées comme égales. Cela signifie qu'un point isolé qui est très éloigné de la moyenne va totalement ruiner tout le calcul. Pour traiter les points de données aberrants et rejeter leur influence considérable après un certain seuil, voir les estimateurs robustes qui intègrent un seuil pour le rejet des valeurs aberrantes en tant qu'événements extrêmement rares qui n'ont pas besoin que leurs résultats excentriques ne changent notre comportement.

Answer 3

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

from sklearn.metrics import mean_squared_error
mean_squared_error(y_actual, y_predicted, squared=False)

Answer 4

C'est probablement plus rapide?:

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

Answer 5

La fonction mean_squared_error de sklearn contient elle-même un paramètre squared avec une valeur par défaut de True. Si nous le définissons à False, la même fonction renverra RMSE au lieu de MSE.

from sklearn.metrics import mean_squared_error
rmse = mean_squared_error(y_true, y_pred , squared=False)