Python'da Kök ortalama kare hatası (RMSE) için bir kütüphane işlevi var mı?

Ben böyle bir kök ortalama kare hata fonksiyonu uygulamak biliyorum:

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

Bu rmse işlevi bir yerde, belki de scipy veya scikit-learn'da bir kütüphanede uygulanırsa ne arıyorum?

sklearn.metricsbir mean_squared_errorişlevi vardır. RMSE, geri döndürdüğü şeyin sadece kareköküdür.

from sklearn.metrics import mean_squared_error
from math import sqrt

rms = sqrt(mean_squared_error(y_actual, y_predicted))

RMSE nedir? MSE, RMD veya RMS olarak da bilinir. Hangi sorunu çözüyor?

RMSE: (Kök ortalama kare hatası), MSE: (Ortalama Kare Hatası) RMD (Kök ortalama kare sapması) ve RMS: (Kök Ortalama Karesi) anlıyorsanız, bunu sizin için hesaplamak için bir kitaplık istemeniz gereksiz aşırı mühendisliktir . Tüm bu metrikler en fazla 2 inç uzunluğunda tek bir python kodu satırıdır. Rmse, mse, rmd ve rms ölçütleri temelde kavramsal olarak aynıdır.

RMSE soruya cevap verir: "ortalama rakamları geldi ne kadar benziyor, list1hiç list2?". İki liste aynı boyutta olmalıdır. "Verilen herhangi iki eleman arasındaki gürültüyü yıkamak, toplanan verilerin boyutunu yıkamak ve zaman içinde değişim için tek bir numara hissi almak istiyorum".

Sezgi ve RMSE için ELI5:

Bir dart tahtasına dart atmayı öğrendiğinizi düşünün. Her gün bir saat çalışıyorsun. İyileşip iyileşmediğini veya kötüleştiğini anlamak istiyorsun. Böylece her gün 10 atış yaparsınız ve bullseye ile dartınızın vurduğu yer arasındaki mesafeyi ölçersiniz.

Bu numaraların bir listesini yaparsınız list1. 1. günde mesafeler ve list2tüm sıfırları içeren bir kök arasındaki ortalama karekök hatası kullanın . 2. ve n. Günlerde de aynısını yapın. Ne elde edeceğiniz umarım zamanla azalan tek bir sayıdır. RMSE numaranız sıfır olduğunda, her seferinde bullseyes vurursunuz. Eğer rmse sayısı artarsa, kötüleşirsiniz.

Python'da kök ortalama kare hatasının hesaplanmasına örnek:

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))

Hangi baskılar:

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

Matematiksel gösterim:

Glif Efsanesi: n atış sayısını temsil eden tamamen pozitif bir tamsayıdır. itoplamı gösteren bir tamsayı tamsayısını temsil eder. Yukarıdaki örnekte tüm sıfırları içeren dideal mesafeler anlamına gelir list2. yukarıdaki örnekte pperformans anlamına gelir list1. üst simge 2, sayısal kare anlamına gelir. d _{i '} nin _id . endeksidir . p _i , _i'nin indeksidir p.

Anlaşılabilmesi için küçük adımlarla yapılan rmse:

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 ^

RMSE'nin her adımı nasıl çalışır:

Bir sayıyı diğerinden çıkarmak, aralarındaki mesafeyi verir.

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

Herhangi bir sayı katını kendisiyle çarparsanız, sonuç her zaman pozitiftir çünkü negatif zamanlar negatiftir:

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

Hepsini toplayın, ancak bekleyin, ardından birçok öğeye sahip bir dizi, küçük bir diziden daha büyük bir hataya sahip olacaktır, bu nedenle bunları öğe sayısına göre ortalayın.

Ama bekleyin, daha önce onları olumlu yönde zorlamak için kareler attık. Karekök ile hasarı geri alın!

Bu, ortalama olarak, list1'in her değeri ile list2'nin karşılık gelen öğe değeri arasındaki mesafeyi temsil eden tek bir sayı bırakır.

RMSE değeri zamanla düşerse, varyans azaldığı için mutlu oluruz .

RMSE en doğru çizgi montaj stratejisi değil, toplam en küçük kareler:

Kök ortalama kare hatası nokta ve çizgi arasındaki dikey mesafeyi ölçer, bu nedenle verileriniz bir muz gibi şekillenirse, dibe yakın düz ve tepeye yakın dikse, RMSE yüksek noktalara daha büyük mesafeler bildirir, ancak kısa mesafeler aslında mesafeler eşdeğer olduğunda düşük puan verir. Bu, çizginin düşükten yüksek noktalara daha yakın olmasını tercih ettiği bir eğriltmeye neden olur.

Bu bir sorunsa, toplam en küçük kareler yöntemi bunu düzeltir: https://mubaris.com/posts/linear-regression

Bu RMSE işlevini kırabilecek Gotcha'lar:

Her iki giriş listesinde de null değeri veya sonsuzluk varsa, çıkış rmse değeri anlamlı olmayacaktır. Her iki listede de null / eksik değerler / sonsuzlarla başa çıkmak için üç strateji vardır: Bu bileşeni yok sayın, sıfırlayın veya tüm zaman sinyallerine en iyi tahmin veya düzgün rastgele bir gürültü ekleyin. Her çözümün, verilerinizin ne anlama geldiğine bağlı olarak artıları ve eksileri vardır. Genel olarak, eksik bir değere sahip herhangi bir bileşeni göz ardı etmek tercih edilir, ancak bu, RMSE'yi sıfıra doğru yönlendirir ve performansın gerçekten olmadığında iyileştiğini düşünmenizi sağlar. Çok fazla eksik değer varsa, en iyi tahminde rastgele gürültü eklemek tercih edilebilir.

RMSE çıkışının göreceli doğruluğunu garanti etmek için girişteki tüm boş / sonsuzları kaldırmalısınız.

RMSE'nin ait olmayan aykırı veri noktaları için sıfır toleransı vardır

Kök ortalama kare hata kareleri tüm verilerin doğru olmasına dayanır ve hepsi eşit olarak sayılır. Bu, sol alanda çıkan bir başıboş noktanın tüm hesaplamayı tamamen mahvedeceği anlamına gelir. Aykırı veri noktalarını ele almak ve belirli bir eşikten sonra muazzam etkilerini ortadan kaldırmak için, Aykırı değerlerin kapatılması için bir eşikte inşa edilen sağlam tahminciler bölümüne bakın.

Bu muhtemelen daha hızlı mı ?:

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

Scikit-learn 0.22.0'da RMSE'yi döndürmek için mean_squared_error()argümanı iletebilirsiniz squared=False.

from sklearn.metrics import mean_squared_error

mean_squared_error(y_actual, y_predicted, squared=False)

Birinin 2019'da bu iş parçacığını bulması durumunda ml_metrics, Kaggle çekirdeklerinde önceden yüklenmeden kullanılabilen, oldukça hafif ve erişilebilen bir kütüphane var pypi(kolayca ve hızlı bir şekilde kurulabilir pip install ml_metrics):

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

O bulunmayan diğer birkaç ilginç metriği var sklearngibi mapk.

Referanslar:

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

Aslında, bir sürü istatistikmodu için faydalı fonksiyonlar yazdım

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

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

Çoğunlukla bir veya iki astar ve çok fazla giriş kontrolü yoktur ve temel olarak dizileri karşılaştırırken bazı istatistikleri kolayca almak için tasarlanmıştır. Ancak eksen argümanları için birim testleri var, çünkü bazen bu noktada özensiz hatalar yapıyorum.

Veya yalnızca NumPy işlevlerini kullanarak:

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

Nerede:

• y benim hedefim
• y_pred benim tahminim

rmse(y, y_pred)==rmse(y_pred, y)Kare fonksiyonu nedeniyle unutmayın .

RMSE işlevini doğrudan SKLearn'de bulamazsınız. Ancak, el ile sqrt yapmak yerine, sklearn kullanarak başka bir standart yol vardır. Görünüşe göre Sklearn'ün mean_squared_error öğesi, varsayılan değeri true olan "squared" olarak adlandırılan bir parametre içeriyor. False olarak ayarlarsak, aynı işlev MSE yerine RMSE döndürür.

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

Aşağıda, iki çokgen dosya biçimi arasındaki RMSE'yi hesaplayan bir örnek kod verilmiştir PLY. Hem ml_metricslib hem de 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. Hayır, Scikit Learn'ün makine öğrenimi için bir kütüphanesi vardır ve Python dili kullanılarak kolayca kullanılabilir. Aşağıdaki bağlantıyı paylaşıyorum Ortalama Kare Hatası için bir işlevi vardır:

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

2. İşlev, aşağıda verildiği gibi mean_squared_error olarak adlandırılır; burada y_true, veri grupları için gerçek sınıf değerleri ve y_pred, kullandığınız makine öğrenme algoritması tarafından öngörülen tahmini değerler olur:

mean_squared_error (y_true, y_pred)

3. RMSE'yi almak için değiştirmeniz gerekiyor (Python kullanarak sqrt işlevini kullanarak) .Bu işlem şu bağlantıda açıklanmıştır: https://www.codeastar.com/regression-model-rmsd/

Yani, son kod şöyle bir şey olurdu:

sklearn.metrics içe aktarım import_squared_error from math import sqrt

RMSD = sqrt (mean_squared_error (test_y; tahmin))

yazdırmak (RMSD)