क्या अजगर में रूट माध्य वर्ग त्रुटि (RMSE) के लिए एक पुस्तकालय कार्य है?

Question

मुझे पता है कि मैं इस तरह एक रूट माध्य चुकता त्रुटि फ़ंक्शन को लागू कर सकता हूं:

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

मैं देख रहा हूँ कि क्या यह rmse फ़ंक्शन कहीं लाइब्रेरी में कार्यान्वित किया गया है, शायद scipy या scikit-learn में?

Comments

आपने समारोह वहीं लिखा है। सबसे अधिक संभावना है कि यदि फ़ंक्शन लिखने में सरल है, तो यह एक पुस्तकालय में नहीं होने वाला है। आप मॉड्यूल नामक एक निर्देशक बनाना और उसमें केवल उपयोगी कार्य करना और इसे अपने पथ पर जोड़ना बेहतर

— समझते हैं

@RyanSaxe मैं असहमत हूं। मुझे लाइब्रेरी फ़ंक्शन को कॉल करने के लिए इसे खुद को फिर से लागू करने के लिए बहुत अधिक आश्वस्त करने वाला लगता है। उदाहरण के लिए, मैंने पहली गलती के .sum()बजाय लिखा था .mean()। इसके अलावा, मुझे लगता है कि यह फ़ंक्शन इतना अधिक उपयोग किया जाता है कि मुझे कोई कारण नहीं दिखता है कि यह लाइब्रेरी फ़ंक्शन के रूप में उपलब्ध क्यों नहीं होना चाहिए।

— स्यामई

@ सियामई: मैं समझता हूं कि 100%, मैं सिर्फ इस कारण से अटकलें लगा रहा था कि इस तरह का कार्य क्यों नहीं हो सकता है। अगर यह है तो मैं इसे ढूंढ नहीं सकता हूं

— रयान सक्से

उन लोगों के लिए जिन्होंने यह कोशिश की थी और यह काम नहीं किया था: यदि predictionsऔर targetsउदाहरण के लिए प्रकार int16वर्ग वर्धित हो सकता है (नकारात्मक संख्या दे रहा है)। तो आपको वर्ग का उपयोग करने से पहले .astype('int')या .astype('double'), जैसे की आवश्यकता हो सकती है np.sqrt(((predictions - targets).astype('double') ** 2).mean())।

— जॉन

स्केलेर में इसके होने का एक और फायदा यह है कि स्केलेर इम्प्लीमेंटेशन में अतिरिक्त बॉइलर प्लेट कोड होता है ताकि यह सुनिश्चित किया जा सके कि सरणियाँ एक ही आकार की हों, और इसमें वेट पैरामीटर भी शामिल हों और मल्टी-डायमेंशनल ऐरे और विभिन्न 'एरे लाइक्स' को भी हैंडल करें। वह सब करना जो इसे और अधिक जटिल समस्या में बदल देता है

— डेविड वाटरवर्थ

Answer 1

sklearn.metricsएक mean_squared_errorसमारोह है। RMSE जो भी रिटर्न देता है उसका वर्गमूल होता है।

from sklearn.metrics import mean_squared_error
from math import sqrt

rms = sqrt(mean_squared_error(y_actual, y_predicted))

Comments

mean_squared_errorमें sklearn.metricsअब अतिरिक्त पैरामीटर का समर्थन करता है: squared- "यह सच है रिटर्न एमएसई मूल्य, झूठी रिटर्न RMSE मूल्य है या नहीं।"

— Daddy32

Answer 2

RMSE क्या है? जिसे MSE, RMD या RMS के रूप में भी जाना जाता है। यह किस समस्या का हल है?

यदि आप RMSE समझते हैं: (रूट माध्य चुकता त्रुटि), MSE: (मीन स्क्वार्ड एरर) RMD (रूट माध्य चुकता विचलन) और RMS: (रूट मीन स्क्वेरड), तो आपके लिए एक लाइब्रेरी की मांग करना आपके लिए अनावश्यक ओवर-इंजीनियरिंग है । ये सभी मीट्रिक अधिकतम 2 इंच लंबे अजगर कोड की एक पंक्ति हैं। तीन मेट्रिक्स rmse, mse, rmd, और rms अपने मूल रूप से समान हैं।

RMSE सवाल का जवाब: "कैसे समान, औसत पर, में नंबर दिए गए हैं list1करने के लिए list2?"। दो सूचियों का आकार समान होना चाहिए। मैं "किसी भी दिए गए तत्वों के बीच शोर को बाहर निकालना चाहता हूं, एकत्र किए गए डेटा के आकार को धोता हूं, और समय के साथ बदलाव के लिए एक ही नंबर महसूस करता हूं"।

RMSE के लिए अंतर्ज्ञान और ELI5:

कल्पना कीजिए कि आप डार्ट बोर्ड में डार्ट्स फेंकना सीख रहे हैं। हर दिन आप एक घंटे के लिए अभ्यास करते हैं। आप यह पता लगाना चाहते हैं कि क्या आप बेहतर हो रहे हैं या खराब हो रहे हैं। तो हर दिन आप 10 थ्रो करें और बुल्सआई के बीच की दूरी को मापें और जहां आपका डार्ट हिट हो।

आप उन नंबरों की एक सूची बनाएं list1। दिन 1 के बीच की दूरी और list2सभी शून्य वाले रूट माध्य चुकता त्रुटि का उपयोग करें । 2 और nth दिनों पर भी ऐसा ही करें। आपको जो मिलेगा, वह एक ही संख्या है जो समय के साथ घटती है। जब आपका RMSE नंबर शून्य होता है, तो आप हर बार बुलबुल को मारते हैं। यदि rmse नंबर बढ़ता है, तो आप खराब हो रहे हैं।

अजगर में मूल माध्य चुकता त्रुटि की गणना में उदाहरण:

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

कौन सा प्रिंट:

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

गणितीय संकेतन:

ग्लिफ़ लीजेंड: n एक संपूर्ण सकारात्मक पूर्णांक है जो थ्रो की संख्या को दर्शाता है। iसंपूर्ण सकारात्मक पूर्णांक काउंटर का प्रतिनिधित्व करता है जो योग की गणना करता है। dआदर्श दूरी के लिए खड़ा है, list2उपरोक्त उदाहरण में सभी शून्य। उपरोक्त उदाहरण में p, प्रदर्शन के लिए खड़ा है list1। सुपरस्क्रिप्ट 2 संख्यात्मक वर्ग के लिए है। घ _मैं की i'th सूचकांक है d। पी _मैं की i'th सूचकांक है p।

छोटे चरणों में किया गया 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 का हर कदम कैसे काम करता है:

एक संख्या को दूसरे से घटाना आपको उनके बीच की दूरी प्रदान करता है।

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

यदि आप किसी भी संख्या को स्वयं गुणा करते हैं, तो परिणाम हमेशा सकारात्मक होता है क्योंकि नकारात्मक समय नकारात्मक होता है:

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

उन सभी को जोड़ें, लेकिन प्रतीक्षा करें, फिर कई तत्वों वाले एक सरणी में एक छोटे सरणी की तुलना में बड़ी त्रुटि होगी, इसलिए उन्हें तत्वों की संख्या से औसत करें।

लेकिन रुको, हमने उन्हें सकारात्मक रूप से बाध्य करने के लिए पहले उन सभी को चुकता किया। एक वर्गमूल के साथ क्षति को पूर्ववत करें!

यह आपको एक एकल संख्या के साथ छोड़ देता है जो औसतन, सूची 1 के प्रत्येक मूल्य के बीच की दूरी सूची 2 के संगत तत्व मान के बीच की दूरी को दर्शाता है।

यदि RMSE मान समय के साथ नीचे चला जाता है तो हम खुश हैं क्योंकि विचरण कम हो रहा है।

RMSE सबसे सटीक लाइन फिटिंग रणनीति नहीं है, कुल कम से कम वर्ग है:

रूट माध्य चुकता त्रुटि बिंदु और रेखा के बीच की ऊर्ध्वाधर दूरी को मापती है, इसलिए यदि आपका डेटा एक केले के आकार का है, तो नीचे के पास समतल है और शीर्ष के पास खड़ी है, तो आरएमएसई उच्च बिंदुओं को अधिक दूरी की रिपोर्ट करेगा, लेकिन कम दूरी कम अंक जब वास्तव में दूरियां बराबर होती हैं। यह एक तिरछा का कारण बनता है जहां रेखा कम से अधिक बिंदुओं के करीब होना पसंद करती है।

यदि यह एक समस्या है तो कुल न्यूनतम वर्ग विधि इसे ठीक करती है: https://mubaris.com/posts/linear-regression

Gotchas जो इस RMSE फ़ंक्शन को तोड़ सकते हैं:

यदि इनपुट सूची में नल या अनंत हैं, तो आउटपुट rmse वैल्यू का कोई मतलब नहीं है। किसी भी सूची में अशक्त / गायब मूल्यों / अनन्तताओं से निपटने के लिए तीन रणनीतियाँ हैं: उस घटक को अनदेखा करें, इसे शून्य करें या सभी टाइमस्टेप्स में एक सर्वोत्तम अनुमान या एक समान यादृच्छिक शोर जोड़ें। प्रत्येक उपाय के अपने नियम और विपक्ष हैं जो आपके डेटा का अर्थ है। सामान्य रूप से किसी भी घटक की अनुपलब्ध मान के साथ अनदेखी की जाती है, लेकिन यह RMSE शून्य की ओर शून्य बनाता है आपको लगता है कि प्रदर्शन में सुधार हुआ है जब यह वास्तव में नहीं हुआ है। सबसे अच्छे अनुमान पर यादृच्छिक शोर जोड़ना पसंद किया जा सकता है यदि बहुत सारे लापता मूल्य हैं।

RMSE आउटपुट के सापेक्ष शुद्धता की गारंटी देने के लिए, आपको इनपुट से सभी नल / इनफिनिटी को खत्म करना होगा।

RMSE में बाह्य डेटा बिंदुओं के लिए शून्य सहिष्णुता है जो संबंधित नहीं हैं

रूट माध्य चुकता त्रुटि वर्ग सभी डेटा सही होने पर निर्भर करता है और सभी को समान रूप से गिना जाता है। इसका मतलब है कि एक आवारा बिंदु जो कि बाएं क्षेत्र में बाहर है, पूरी गणना को पूरी तरह से बर्बाद करने वाला है। बाहरी डेटा बिंदुओं को संभालने और एक निश्चित सीमा के बाद उनके जबरदस्त प्रभाव को खारिज करने के लिए, रोबस्ट अनुमानक देखें जो आउटलेर्स की बर्खास्तगी के लिए एक सीमा में निर्माण करते हैं।

Comments

हाँ, सरल कार्य। लेकिन अगर आपको इसे दिन-प्रतिदिन के उपयोग की आवश्यकता है, तो इसका अच्छा उपयोग करें कहीं न कहीं एक सही समाधान उपलब्ध है ताकि आपको इसे हर बार फिर से लागू न करना पड़े; )

— तार्किक एक्स 2

@ eric-leschinski, अगर आप इस पर एक नज़र डाल सकते हैं, तो मैं सराहना करूंगा: stackoverflow.com/questions/45173451/…

— डेस्टा

यह निश्चित रूप से इस पीढ़ी का संकेत है जो लोग बहु-गीगाबाइट आकार के पुस्तकालयों के लिए पूछते हैं और इंगित करते हैं; 3 से 20 मिनट के नेटवर्क डाउनलोड की आवश्यकता होती है तब CPU फुल-टिल्ट इंस्टॉल होता है, जब आपको वास्तव में कोड की लगभग 3 लाइनों की आवश्यकता होती है जो 400 बाइट्स में फिट होती है। यदि आप एक नौकरी के लिए एक पुस्तकालय की मांग करते हैं जिसे कोड की 1 पंक्ति में संपीड़ित किया जा सकता है, जो कि लगभग 90 वर्णों का चौड़ा है, तो आप लोगों को 3, 10 के साथ दुर्व्यवहार करने का लाइसेंस दे रहे हैं, और जल्द ही 50GB आकार के इंस्टॉलेशन जो 99.9999 हैं % ब्लत। यह रॉकेट सर्जरी नहीं है। 1978 में 740hz प्रोसेसर के साथ आपका सौर ऊर्जा संचालित कैलकुलेटर RMSE कर सकता है।

— एरिक लेसचिंस्की

Answer 3

यह शायद तेज है ?:

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

Answer 4

Scikit-0.22.0 में जानें आप RMSE को वापस करने के mean_squared_error()लिए तर्क पारित कर सकते हैं squared=False।

from sklearn.metrics import mean_squared_error

mean_squared_error(y_actual, y_predicted, squared=False)

Comments

यह नई सुविधा है और हम इसका उपयोग करेंगे तो सबसे अच्छा होगा।

— रवि जी

Answer 5

बस अगर किसी को 2019 में यह धागा मिलता है, तो एक पुस्तकालय है जिसे ml_metricsकागल की गुठली में पूर्व-स्थापना के बिना उपलब्ध है, बहुत हल्का और pypiइसके माध्यम से सुलभ है (इसे आसानी से और तेजी से स्थापित किया जा सकता है pip install ml_metrics):

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

इसके कुछ अन्य रोचक मेट्रिक्स हैं जो इसमें उपलब्ध नहीं हैं sklearn, जैसे mapk।

संदर्भ:

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

Answer 6

दरअसल, मैंने स्टैटमॉडल के लिए उपयोगिता कार्यों के रूप में उन लोगों का एक गुच्छा लिखा था

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

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

ज्यादातर एक या दो लाइनर और ज्यादा इनपुट चेकिंग नहीं, और मुख्य रूप से सरणियों की तुलना करते समय आसानी से कुछ आंकड़े प्राप्त करने का इरादा होता है। लेकिन उनके पास अक्ष तर्कों के लिए इकाई परीक्षण हैं, क्योंकि यही वह जगह है जहां मैं कभी-कभी गलत तरीके से गलतियां करता हूं।

Answer 7

या केवल केवल NumPy फ़ंक्शन का उपयोग करके:

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

कहाँ पे:

• y मेरा लक्ष्य है
• y_pred मेरी भविष्यवाणी है

ध्यान दें कि rmse(y, y_pred)==rmse(y_pred, y)वर्ग फ़ंक्शन के कारण।

Answer 8

आप SKMS में सीधे RMSE फ़ंक्शन नहीं पा सकते हैं। लेकिन, मैन्युअल रूप से sqrt करने के बजाय, sklearn का उपयोग करने का एक और मानक तरीका है। जाहिरा तौर पर, स्केलेर के माध्य_squared_error में एक पैरामीटर होता है, जिसे "चुकता" के रूप में बुलाया जाता है, जिसका मान सही होता है। यदि हम इसे गलत पर सेट करते हैं, तो वही फ़ंक्शन MSE के बजाय RMSE को लौटा देगा।

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

Answer 9

यहां एक उदाहरण कोड है जो दो बहुभुज फ़ाइल स्वरूपों के बीच RMSE की गणना करता है PLY। यह दोनों का उपयोग करता हैml_metrics लिब और है 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])

Answer 10

1. नहीं, मशीन लर्निंग के लिए एक लाइब्रेरी स्किकिट लर्न है और इसे पायथन भाषा का उपयोग करके आसानी से नियोजित किया जा सकता है। यह मीन चुकता त्रुटि के लिए एक समारोह है जो मैं नीचे लिंक साझा कर रहा हूँ:

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

2. फ़ंक्शन का अर्थ नीचे दिया गया है जैसा कि नीचे दिया गया है, जहां y_true डेटा ट्यूपल्स के लिए वास्तविक वर्ग मान होगा और y_pred पूर्वानुमानित मान होगा, जो आपके द्वारा उपयोग किए जा रहे मशीन लर्निंग एल्गोरिदम द्वारा भविष्यवाणी की गई है:

mean_squared_error (y_true, y_pred)

3. RMSE (Python का उपयोग करके sqrt फ़ंक्शन का उपयोग करके) प्राप्त करने के लिए आपको इसे संशोधित करना होगा। यह प्रक्रिया इस लिंक में वर्णित है: https://www.codeastar.com/regression-model-rmsd/

तो, अंतिम कोड कुछ इस तरह होगा:

sklearn.metrics से गणित आयात sqrt से mean_squared_error आयात करते हैं

RMSD = sqrt (mean_squared_error (testing_y, prediction))

प्रिंट (RMSD)