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

Voici un exemple de code qui calcule le RMSE entre deux formats de fichiers polygonaux PLY. Il utilise à la fois la librairie ml_metrics et 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  ")
    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])

Answer 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. Elle dispose d'une fonction pour l'erreur quadratique moyenne que 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 les valeurs de classe réelles pour les tuples de données et y_pred seraient 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 Python). Ce processus est décrit dans ce lien : https://www.codeastar.com/regression-model-rmsd/

Donc, le code final ressemblerait à :

from sklearn.metrics import mean_squared_error from math import sqrt

RMSD = sqrt(mean_squared_error(testing_y, prediction))

print(RMSD)

Answer 3

Vous voudrez peut-être ajouter la valeur absolue np.abs si vous travaillez avec des nombres complexes.

import numpy as np
rms = np.sqrt(np.mean(np.abs(x-y)**2))

Notez que si vous utilisez np.linalg.norm, cela s'occupe déjà des nombres complexes.

import numpy as np
rms = np.linalg.norm(x-y)/np.sqrt(len(x))

Answer 4

Benchmark

For specific use case that you don't need overhead handler and always expecting numpy array input, the fastest way is to manually write function in numpy. Even more, you can use numba to speed it up if you call it frequently.

import numpy as np
from numba import jit
from sklearn.metrics import mean_squared_error

%%timeit
mean_squared_error(y[i],y[j], squared=False)

445 µs ± 90.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

def euclidian_distance(y1, y2):
    """
    RMS Euclidean method
    """
    return np.sqrt(((y1-y2)**2).mean())

%%timeit
euclidian_distance(y[i],y[j])

28.8 µs ± 2.54 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

@jit(nopython=True)
def jit_euclidian_distance(y1, y2):
    """
    RMS Euclidean method
    """
    return np.sqrt(((y1-y2)**2).mean())

%%timeit
jit_euclidian_distance(y[i],y[j])

2.1 µs ± 234 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

@jit(nopython=True)
def jit2_euclidian_distance(y1, y2):
    """
    RMS Euclidean method
    """
    return np.linalg.norm(y1-y2)/np.sqrt(y1.shape[0])

%%timeit
jit2_euclidian_distance(y[i],y[j])

2.67 µs ± 60.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Extra note: In my use case, numba give slightly different but negligible result on np.sqrt(((y1-y2)**2).mean()), where without numba, the result will be equal to scipy result. Try it yourself.