มีฟังก์ชั่นห้องสมุดสำหรับรูทหมายความว่าข้อผิดพลาดแบบสี่เหลี่ยม (RMSE) ในไพ ธ อนหรือไม่?

ฉันรู้ว่าฉันสามารถใช้รูทค่าเฉลี่ยของข้อผิดพลาดกำลังสองได้ดังนี้:

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

สิ่งที่ฉันกำลังมองหาถ้าฟังก์ชั่น rmse นี้ถูกนำไปใช้ในห้องสมุดแห่งหนึ่งบางทีอาจจะเป็นในแบบ scipy หรือ scikit-Learn?

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

RMSE คืออะไร หรือที่เรียกว่า MSE, RMD หรือ RMS มันแก้ปัญหาอะไรได้บ้าง?

ถ้าคุณเข้าใจ RMSE: (ข้อผิดพลาดรูตเฉลี่ยกำลังสอง), MSE: (ข้อผิดพลาดกำลังสองเฉลี่ย) RMD (รูตเฉลี่ยเบี่ยงเบนกำลังสอง) และ RMS: (รูตเฉลี่ยกำลังสอง), ดังนั้นการขอให้ห้องสมุดคำนวณสิ่งนี้สำหรับคุณ . ตัวชี้วัดทั้งหมดเหล่านี้เป็นรหัสไพ ธ อนบรรทัดเดียวที่ยาวไม่เกิน 2 นิ้ว สามเมทริก rmse, mse, rmd และ rms อยู่ที่แกนหลักของพวกเขาที่มีแนวคิดเหมือนกัน

RMSE ตอบคำถาม: "วิธีการที่คล้ายกันโดยเฉลี่ยเป็นตัวเลขในlist1การlist2 ?" รายการทั้งสองจะต้องมีขนาดเท่ากัน ฉันต้องการ "ขจัดเสียงรบกวนระหว่างองค์ประกอบสองอย่างที่กำหนดล้างขนาดของข้อมูลที่รวบรวมและรับความรู้สึกจำนวนเดียวสำหรับการเปลี่ยนแปลงตลอดเวลา"

ปรีชาและ ELI5 สำหรับ RMSE:

ลองนึกภาพคุณกำลังเรียนรู้การโยนลูกดอกที่กระดานปาเป้า ทุกวันที่คุณฝึกฝนเป็นเวลาหนึ่งชั่วโมง คุณต้องการทราบว่าคุณดีขึ้นหรือแย่ลง ดังนั้นทุกวันคุณจะขว้าง 10 ครั้งและวัดระยะห่างระหว่างเป้าและที่โผของคุณชน

list1คุณทำให้รายการของตัวเลขเหล่านั้น ใช้ข้อผิดพลาดกำลังสองเฉลี่ยของรูทระหว่างระยะทางในวันที่ 1 และศูนย์list2ที่มีค่าศูนย์ทั้งหมด ทำเช่นเดียวกันในวันที่ 2 และวันที่ สิ่งที่คุณจะได้รับคือตัวเลขเดียวที่หวังว่าจะลดลงเมื่อเวลาผ่านไป เมื่อหมายเลข 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

สัญกรณ์ทางคณิตศาสตร์:

Glyph Legend: nเป็นจำนวนเต็มบวกทั้งหมดที่แสดงจำนวนการโยน iแสดงถึงตัวนับจำนวนเต็มบวกทั้งหมดที่ระบุผลรวม dย่อมาจากระยะทางในอุดมคติที่list2มีศูนย์ทั้งหมดในตัวอย่างข้างต้น pย่อมาจากประสิทธิภาพlist1ในตัวอย่างข้างต้น superscript 2 หมายถึงกำลังสองเป็นตัวเลข d _ฉันเป็นดัชนี 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

เพิ่มพวกเขาทั้งหมด แต่รอแล้วอาร์เรย์ที่มีหลายองค์ประกอบจะมีข้อผิดพลาดที่ใหญ่กว่าอาร์เรย์ขนาดเล็กดังนั้นค่าเฉลี่ยพวกเขาตามจำนวนขององค์ประกอบ

แต่เดี๋ยวก่อนเรากำลังสองพวกมันทั้งหมดก่อนหน้านี้เพื่อบังคับพวกมันให้เป็นบวก เลิกทำดาเมจด้วยรากที่สอง!

นั่นทำให้คุณมีหมายเลขเดียวที่แสดงโดยเฉลี่ยระยะทางระหว่างทุกค่าของ list1 กับค่าองค์ประกอบที่สอดคล้องกันของ list2

หากค่า RMSE ลดลงเมื่อเวลาผ่านไปเรายินดีเพราะความแปรปรวนลดลง

RMSE ไม่ใช่กลยุทธ์การวางสายที่แม่นยำที่สุดโดยรวมกำลังสองน้อยที่สุดคือ:

ค่าเฉลี่ยรากของข้อผิดพลาดกำลังสองวัดระยะทางแนวตั้งระหว่างจุดและเส้นดังนั้นหากข้อมูลของคุณมีรูปร่างเหมือนกล้วยแบนใกล้กับด้านล่างและสูงชันใกล้ด้านบน RMSE จะรายงานระยะทางมากขึ้นถึงจุดสูง แต่ระยะทางสั้น ๆ ไป คะแนนต่ำเมื่อในความเป็นจริงระยะทางเทียบเท่า สิ่งนี้ทำให้เกิดความเบ้ซึ่งเส้นนั้นชอบที่จะเข้าใกล้กับจุดที่สูงกว่าต่ำ

หากนี่เป็นปัญหาวิธีกำลังสองน้อยที่สุดจะแก้ไขสิ่งนี้: https://mubaris.com/posts/linear-regression

Gotchas ที่สามารถทำลายฟังก์ชัน RMSE นี้:

หากมีโมฆะหรืออินฟินิตี้ในรายการอินพุตอย่างใดอย่างหนึ่งแล้วค่าเอาท์พุท rmse จะไม่เหมาะสม มีสามกลยุทธ์ในการจัดการกับค่าโมฆะ / ค่าที่ขาดหายไป / อินฟินิตี้ในรายการใดรายการหนึ่ง: ละเว้นองค์ประกอบนั้นให้เป็นศูนย์หรือเพิ่มการคาดเดาที่ดีที่สุด การรักษาแต่ละวิธีมีข้อดีข้อเสียของมันขึ้นอยู่กับความหมายของข้อมูลของคุณ โดยทั่วไปไม่ต้องการส่วนประกอบใด ๆ ที่มีค่าที่ขาดหายไป แต่อคติ RMSE นี้มีค่าเป็นศูนย์ทำให้คุณคิดว่าประสิทธิภาพจะดีขึ้นเมื่อไม่ได้ใช้งานจริง การเพิ่มสัญญาณรบกวนแบบสุ่มในการเดาที่ดีที่สุดอาจเป็นที่ต้องการหากมีค่าที่ขาดหายไปจำนวนมาก

เพื่อรับประกันความถูกต้องสัมพัทธ์ของเอาต์พุต RMSE คุณต้องกำจัด nulls / infinites ทั้งหมดออกจากอินพุต

RMSE มีความอดทนเป็นศูนย์สำหรับจุดข้อมูลที่ไม่มีค่า

รูทค่าเฉลี่ยกำลังสองข้อผิดพลาดกำลังสองขึ้นอยู่กับข้อมูลทั้งหมดที่ถูกต้องและทั้งหมดจะถูกนับเป็นเท่ากับ นั่นหมายถึงจุดหนึ่งหลงทางที่อยู่ทางด้านซ้ายจะเป็นการทำลายการคำนวณทั้งหมด หากต้องการจัดการกับจุดข้อมูลที่ล้าสมัยและยกเลิกอิทธิพลอย่างมากหลังจากขีด จำกัด บางตัวโปรดดูตัวประมาณที่แข็งแกร่งซึ่งสร้างขึ้นในขีด จำกัด สำหรับการเลิกจ้างค่าผิดปกติ

นี่อาจจะเร็วกว่า:

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

ใน Scikit เรียนรู้ 0.22.0 คุณสามารถผ่านmean_squared_error()การโต้แย้งsquared=Falseเพื่อกลับ RMSE

from sklearn.metrics import mean_squared_error

mean_squared_error(y_actual, y_predicted, squared=False)

ในกรณีที่มีคนค้นพบกระทู้นี้ในปี 2019 มีห้องสมุดที่เรียกml_metricsใช้ได้โดยไม่ต้องทำการติดตั้งล่วงหน้าในเมล็ดของ Kaggle ซึ่งมีน้ำหนักเบาและเข้าถึงได้ง่ายผ่านทาง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

ที่จริงแล้วฉันเขียนกลุ่มเหล่านั้นเป็นฟังก์ชั่นยูทิลิตี้สำหรับสถิติรุ่น

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

ส่วนใหญ่หนึ่งหรือสองตอร์ปิโดและการตรวจสอบอินพุตไม่มากและมีวัตถุประสงค์หลักเพื่อให้ได้รับสถิติบางอย่างเมื่อเปรียบเทียบอาร์เรย์ แต่พวกเขามีการทดสอบหน่วยสำหรับข้อโต้แย้งของแกนเพราะบางครั้งฉันทำผิดพลาดเลอะเทอะ

หรือเพียงแค่ใช้ฟังก์ชั่น 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)เนื่องจากฟังก์ชั่นสแควร์

คุณไม่พบฟังก์ชัน RMSE ใน SKLearn โดยตรง แต่แทนที่จะทำ sqrt ด้วยตนเองมีวิธีมาตรฐานอีกวิธีหนึ่งที่ใช้ sklearn เห็นได้ชัดว่า mean_squared_error ของ Sklearn เองมีพารามิเตอร์ที่เรียกว่า "squared" โดยมีค่าเริ่มต้นเป็น true หากเราตั้งค่าเป็นเท็จฟังก์ชันเดียวกันจะส่งคืน RMSE แทน MSE

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

นี่คือตัวอย่างโค้ดที่คำนวณ RMSE PLYระหว่างสองรูปแบบไฟล์รูปหลายเหลี่ยม มันใช้ทั้งml_metricslib และ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. ไม่มีห้องสมุด Scikit Learn สำหรับการเรียนรู้ของเครื่องและสามารถใช้งานได้ง่ายโดยใช้ภาษา Python มันมีฟังก์ชั่นสำหรับ Mean Squared Error ที่ฉันแบ่งปันลิงค์ด้านล่าง:

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

2. ฟังก์ชั่นชื่อ mean_squared_error ตามที่ระบุด้านล่างโดยที่ y_true จะเป็นค่าคลาสจริงสำหรับ tuples ข้อมูลและ y_pred จะเป็นค่าที่คาดการณ์ไว้ซึ่งทำนายโดยอัลกอริทึมการเรียนรู้ของเครื่องที่คุณใช้:

mean_squared_error (y_true, y_pred)

3. คุณต้องแก้ไขมันเพื่อรับ RMSE (โดยใช้ฟังก์ชั่น sqrt โดยใช้ Python) กระบวนการนี้อธิบายไว้ในลิงค์นี้: https://www.codeastar.com/regression-model-rmsd/

ดังนั้นรหัสสุดท้ายจะเป็นดังนี้:

จาก sklearn.metrics นำเข้า mean_squared_error จาก sqrt นำเข้าคณิตศาสตร์

RMSD = sqrt (mean_squared_error (test_y การทำนาย))

พิมพ์ (RMSD)