ฉันจะคำนวณ r-squared โดยใช้ Python และ Numpy ได้อย่างไร

ฉันใช้ Python และ Numpy เพื่อคำนวณพหุนามที่เหมาะสมที่สุดของการศึกษาระดับปริญญาโดยพลการ ฉันส่งรายการค่า x ค่า y และระดับของพหุนามที่ฉันต้องการให้พอดี (เชิงเส้นกำลังสอง ฯลฯ )

สิ่งนี้ได้ผลมาก แต่ฉันก็ต้องการคำนวณ r (สัมประสิทธิ์สหสัมพันธ์) และ r-squared (สัมประสิทธิ์การกำหนด) ฉันกำลังเปรียบเทียบผลลัพธ์ของฉันกับความสามารถของเส้นแนวโน้มที่เหมาะสมที่สุดของ Excel และค่า r-squared ที่คำนวณ เมื่อใช้สิ่งนี้ฉันรู้ว่าฉันกำลังคำนวณ r-squared อย่างถูกต้องสำหรับ linear best-fit (องศาเท่ากับ 1) อย่างไรก็ตามฟังก์ชันของฉันใช้ไม่ได้กับพหุนามที่มีระดับมากกว่า 1

Excel สามารถทำได้ ฉันจะคำนวณ r-squared สำหรับพหุนามลำดับสูงกว่าโดยใช้ Numpy ได้อย่างไร

นี่คือหน้าที่ของฉัน:

import numpy

# Polynomial Regression
def polyfit(x, y, degree):
    results = {}

    coeffs = numpy.polyfit(x, y, degree)
     # Polynomial Coefficients
    results['polynomial'] = coeffs.tolist()

    correlation = numpy.corrcoef(x, y)[0,1]

     # r
    results['correlation'] = correlation
     # r-squared
    results['determination'] = correlation**2

    return results

จากเอกสารnumpy.polyfitเป็นการปรับการถดถอยเชิงเส้นให้เหมาะสม โดยเฉพาะ numpy.polyfit ที่มีองศา 'd' พอดีกับการถดถอยเชิงเส้นด้วยฟังก์ชันค่าเฉลี่ย

E (y | x) = p_d * x ** d + p_ {d-1} * x ** (d-1) + ... + p_1 * x + p_0

คุณก็ต้องคำนวณ R กำลังสองให้พอดี หน้าวิกิพีเดียเกี่ยวกับการถดถอยเชิงเส้นจะให้รายละเอียดทั้งหมด คุณสนใจ R ^ 2 ซึ่งคุณสามารถคำนวณได้หลายวิธีวิธีที่ง่ายที่สุดอาจเป็นได้

SST = Sum(i=1..n) (y_i - y_bar)^2
SSReg = Sum(i=1..n) (y_ihat - y_bar)^2
Rsquared = SSReg/SST

โดยที่ฉันใช้ 'y_bar' สำหรับค่าเฉลี่ยของ y และ 'y_ihat' เป็นค่าพอดีสำหรับแต่ละจุด

ฉันไม่ค่อยคุ้นเคยกับ numpy มากนัก (โดยปกติฉันทำงานใน R) ดังนั้นอาจมีวิธีที่เป็นระเบียบกว่าในการคำนวณ R-squared ของคุณ แต่สิ่งต่อไปนี้ควรถูกต้อง

import numpy

# Polynomial Regression
def polyfit(x, y, degree):
    results = {}

    coeffs = numpy.polyfit(x, y, degree)

     # Polynomial Coefficients
    results['polynomial'] = coeffs.tolist()

    # r-squared
    p = numpy.poly1d(coeffs)
    # fit values, and mean
    yhat = p(x)                         # or [p(z) for z in x]
    ybar = numpy.sum(y)/len(y)          # or sum(y)/len(y)
    ssreg = numpy.sum((yhat-ybar)**2)   # or sum([ (yihat - ybar)**2 for yihat in yhat])
    sstot = numpy.sum((y - ybar)**2)    # or sum([ (yi - ybar)**2 for yi in y])
    results['determination'] = ssreg / sstot

    return results

การตอบกลับล่าช้ามาก แต่ในกรณีที่มีคนต้องการฟังก์ชันที่พร้อมสำหรับสิ่งนี้:

scipy.stats.linregress

กล่าวคือ

slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(x, y)

เช่นเดียวกับคำตอบของ @Adam Marples

จาก yanl (yet-another-library) sklearn.metricsมีr2_scoreฟังก์ชัน;

from sklearn.metrics import r2_score

coefficient_of_dermination = r2_score(y, p(x))

ฉันใช้สิ่งนี้สำเร็จโดยที่ x และ y เป็นเหมือนอาร์เรย์

def rsquared(x, y):
    """ Return R^2 where x and y are array-like."""

    slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(x, y)
    return r_value**2

แต่เดิมฉันโพสต์เกณฑ์มาตรฐานด้านล่างโดยมีจุดประสงค์เพื่อแนะนำnumpy.corrcoefโดยโง่เขลาที่ไม่ตระหนักว่าคำถามเดิมใช้อยู่แล้วcorrcoefและในความเป็นจริงกำลังถามเกี่ยวกับความพอดีของพหุนามลำดับที่สูงกว่า ฉันได้เพิ่มวิธีแก้ปัญหาจริงให้กับคำถามพหุนาม r-squared โดยใช้ statsmodels และฉันได้ทิ้งเกณฑ์มาตรฐานเดิมซึ่งในขณะที่นอกหัวข้ออาจเป็นประโยชน์กับใครบางคน

statsmodelsมีความสามารถในการคำนวณr^2พหุนามพอดีโดยตรงนี่คือ 2 วิธี ...

import statsmodels.api as sm
import statsmodels.formula.api as smf

# Construct the columns for the different powers of x
def get_r2_statsmodels(x, y, k=1):
    xpoly = np.column_stack([x**i for i in range(k+1)])    
    return sm.OLS(y, xpoly).fit().rsquared

# Use the formula API and construct a formula describing the polynomial
def get_r2_statsmodels_formula(x, y, k=1):
    formula = 'y ~ 1 + ' + ' + '.join('I(x**{})'.format(i) for i in range(1, k+1))
    data = {'x': x, 'y': y}
    return smf.ols(formula, data).fit().rsquared # or rsquared_adj

หากต้องการใช้ประโยชน์เพิ่มเติมstatsmodelsควรดูที่ข้อมูลสรุปโมเดลที่ติดตั้งซึ่งสามารถพิมพ์หรือแสดงเป็นตาราง HTML ที่สมบูรณ์ในสมุดบันทึก Jupyter / IPython rsquaredวัตถุผลให้การเข้าถึงตัวชี้วัดทางสถิติที่มีประโยชน์มากมายนอกเหนือไปจาก

model = sm.OLS(y, xpoly)
results = model.fit()
results.summary()

ด้านล่างนี้คือคำตอบเดิมของฉันที่ฉันเปรียบเทียบวิธีการถดถอยเชิงเส้นต่างๆ r ^ 2 ...

corrcoefฟังก์ชั่นที่ใช้ในคำถามที่คำนวณค่าสัมประสิทธิ์สหสัมพันธ์ที่rเพียงสำหรับการถดถอยเชิงเส้นเดียวดังนั้นจึงไม่ได้อยู่ที่คำถามของr^2สำหรับการสั่งซื้อที่สูงขึ้นเหมาะกับพหุนาม แต่สำหรับสิ่งที่คุ้มค่า, rฉันได้มาพบว่าสำหรับการถดถอยเชิงเส้นมันย่อมเป็นวิธีที่เร็วที่สุดและตรงที่สุดในการคำนวณ

def get_r2_numpy_corrcoef(x, y):
    return np.corrcoef(x, y)[0, 1]**2

นี่คือผลการจับเวลาของฉันจากการเปรียบเทียบวิธีการต่างๆสำหรับ 1,000 จุดสุ่ม (x, y):

• Pure Python (การrคำนวณโดยตรง)
  • 1,000 ลูปซึ่งดีที่สุดคือ 3: 1.59 ms ต่อลูป
• polyfit ที่เป็นก้อน (ใช้ได้กับพหุนามดีกรี n)
  • 1,000 ลูปดีที่สุด 3: 3266s ต่อลูป
• Numpy Manual ( rคำนวณโดยตรง)
  • 10,000 ลูปดีที่สุด 3: 62.1 µs ต่อลูป
• Numpy corrcoef ( rคำนวณโดยตรง)
  • 10,000 ลูปดีที่สุด 3: 56.6.6s ต่อลูป
• Scipy (การถดถอยเชิงเส้นด้วยrเป็นเอาต์พุต)
  • 1,000 ลูปดีที่สุด 3: 676 วินาทีต่อลูป
• Statsmodels (สามารถทำพหุนามระดับ n และอื่น ๆ อีกมากมาย)
  • 1,000 ลูปดีที่สุด 3: 422 pers ต่อลูป

วิธี corrcoef เอาชนะการคำนวณ r ^ 2 "ด้วยตนเอง" ได้อย่างแคบโดยใช้วิธี numpy เร็วกว่าวิธี polyfit> 5 เท่าและเร็วกว่า scipy.linregress ~ 12 เท่า เพียงเพื่อเสริมสร้างสิ่งที่ numpy กำลังทำเพื่อคุณมันเร็วกว่า python บริสุทธิ์ 28 เท่า ฉันไม่ได้เชี่ยวชาญในสิ่งต่างๆเช่น numba และ pypy ดังนั้นคนอื่นจะต้องเติมช่องว่างเหล่านั้น แต่ฉันคิดว่านี่เป็นสิ่งที่น่าเชื่อสำหรับฉันมากว่าcorrcoefเป็นเครื่องมือที่ดีที่สุดในการคำนวณrการถดถอยเชิงเส้นอย่างง่าย

นี่คือรหัสเปรียบเทียบของฉัน ฉันคัดลอกมาจาก Jupyter Notebook (ยากที่จะไม่เรียกมันว่า IPython Notebook ... ) ดังนั้นฉันต้องขออภัยหากมีสิ่งใดขัดข้องระหว่างทาง คำสั่ง% timeit magic ต้องใช้ IPython

import numpy as np
from scipy import stats
import statsmodels.api as sm
import math

n=1000
x = np.random.rand(1000)*10
x.sort()
y = 10 * x + (5+np.random.randn(1000)*10-5)

x_list = list(x)
y_list = list(y)

def get_r2_numpy(x, y):
    slope, intercept = np.polyfit(x, y, 1)
    r_squared = 1 - (sum((y - (slope * x + intercept))**2) / ((len(y) - 1) * np.var(y, ddof=1)))
    return r_squared
    
def get_r2_scipy(x, y):
    _, _, r_value, _, _ = stats.linregress(x, y)
    return r_value**2
    
def get_r2_statsmodels(x, y):
    return sm.OLS(y, sm.add_constant(x)).fit().rsquared
    
def get_r2_python(x_list, y_list):
    n = len(x_list)
    x_bar = sum(x_list)/n
    y_bar = sum(y_list)/n
    x_std = math.sqrt(sum([(xi-x_bar)**2 for xi in x_list])/(n-1))
    y_std = math.sqrt(sum([(yi-y_bar)**2 for yi in y_list])/(n-1))
    zx = [(xi-x_bar)/x_std for xi in x_list]
    zy = [(yi-y_bar)/y_std for yi in y_list]
    r = sum(zxi*zyi for zxi, zyi in zip(zx, zy))/(n-1)
    return r**2
    
def get_r2_numpy_manual(x, y):
    zx = (x-np.mean(x))/np.std(x, ddof=1)
    zy = (y-np.mean(y))/np.std(y, ddof=1)
    r = np.sum(zx*zy)/(len(x)-1)
    return r**2
    
def get_r2_numpy_corrcoef(x, y):
    return np.corrcoef(x, y)[0, 1]**2
    
print('Python')
%timeit get_r2_python(x_list, y_list)
print('Numpy polyfit')
%timeit get_r2_numpy(x, y)
print('Numpy Manual')
%timeit get_r2_numpy_manual(x, y)
print('Numpy corrcoef')
%timeit get_r2_numpy_corrcoef(x, y)
print('Scipy')
%timeit get_r2_scipy(x, y)
print('Statsmodels')
%timeit get_r2_statsmodels(x, y)

R-squared เป็นสถิติที่ใช้กับการถดถอยเชิงเส้นเท่านั้น

โดยพื้นฐานแล้วจะวัดความแปรผันของข้อมูลของคุณที่สามารถอธิบายได้โดยการถดถอยเชิงเส้น

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

\ sum_ {i} (y_ {i} - y_bar) ^ 2

โดยที่ y_bar คือค่าเฉลี่ยของค่า y

จากนั้นคุณคำนวณ "ผลรวมการถดถอยของกำลังสอง" ซึ่งเป็นค่า FITTED ของคุณแตกต่างจากค่าเฉลี่ยมากเพียงใด

\ sum_ {i} (yHat_ {i} - y_bar) ^ 2

และหาอัตราส่วนของทั้งสอง

ตอนนี้สิ่งที่คุณต้องทำเพื่อความพอดีของพหุนามคือเสียบ y_hat จากโมเดลนั้น แต่การเรียก r-squared นั้นไม่ถูกต้อง

นี่คือลิงค์ที่ฉันพบซึ่งพูดถึงมันเล็กน้อย

บทความวิกิพีเดียเกี่ยวกับr-squaredsชี้ให้เห็นว่าอาจใช้สำหรับการปรับรูปแบบทั่วไปมากกว่าการถดถอยเชิงเส้น

นี่คือฟังก์ชั่นในการคำนวณr-squared ที่ถ่วงน้ำหนักด้วย Python และ Numpy (โค้ดส่วนใหญ่มาจาก sklearn):

from __future__ import division 
import numpy as np

def compute_r2_weighted(y_true, y_pred, weight):
    sse = (weight * (y_true - y_pred) ** 2).sum(axis=0, dtype=np.float64)
    tse = (weight * (y_true - np.average(
        y_true, axis=0, weights=weight)) ** 2).sum(axis=0, dtype=np.float64)
    r2_score = 1 - (sse / tse)
    return r2_score, sse, tse

ตัวอย่าง:

from __future__ import print_function, division 
import sklearn.metrics 

def compute_r2_weighted(y_true, y_pred, weight):
    sse = (weight * (y_true - y_pred) ** 2).sum(axis=0, dtype=np.float64)
    tse = (weight * (y_true - np.average(
        y_true, axis=0, weights=weight)) ** 2).sum(axis=0, dtype=np.float64)
    r2_score = 1 - (sse / tse)
    return r2_score, sse, tse    

def compute_r2(y_true, y_predicted):
    sse = sum((y_true - y_predicted)**2)
    tse = (len(y_true) - 1) * np.var(y_true, ddof=1)
    r2_score = 1 - (sse / tse)
    return r2_score, sse, tse

def main():
    '''
    Demonstrate the use of compute_r2_weighted() and checks the results against sklearn
    '''        
    y_true = [3, -0.5, 2, 7]
    y_pred = [2.5, 0.0, 2, 8]
    weight = [1, 5, 1, 2]
    r2_score = sklearn.metrics.r2_score(y_true, y_pred)
    print('r2_score: {0}'.format(r2_score))  
    r2_score,_,_ = compute_r2(np.array(y_true), np.array(y_pred))
    print('r2_score: {0}'.format(r2_score))
    r2_score = sklearn.metrics.r2_score(y_true, y_pred,weight)
    print('r2_score weighted: {0}'.format(r2_score))
    r2_score,_,_ = compute_r2_weighted(np.array(y_true), np.array(y_pred), np.array(weight))
    print('r2_score weighted: {0}'.format(r2_score))

if __name__ == "__main__":
    main()
    #cProfile.run('main()') # if you want to do some profiling

ผลลัพธ์:

r2_score: 0.9486081370449679
r2_score: 0.9486081370449679
r2_score weighted: 0.9573170731707317
r2_score weighted: 0.9573170731707317

สิ่งนี้สอดคล้องกับสูตร ( มิเรอร์ ):

ด้วย f_i คือค่าที่คาดการณ์จากความพอดี y_ {av} คือค่าเฉลี่ยของข้อมูลที่สังเกตได้ y_i คือค่าข้อมูลที่สังเกตได้ w_i คือการถ่วงน้ำหนักที่ใช้กับจุดข้อมูลแต่ละจุดโดยปกติคือ w_i = 1 SSE คือผลรวมของกำลังสองเนื่องจากข้อผิดพลาดและ SST คือผลรวมของกำลังสอง

หากสนใจรหัสใน R: https://gist.github.com/dhimmel/588d64a73fa4fef02c8f ( มิเรอร์ )

นี่คือฟังก์ชัน python ที่ง่ายมากในการคำนวณ R ^ 2 จากค่าจริงและค่าที่คาดการณ์โดยสมมติว่า y และ y_hat เป็นอนุกรมแพนด้า:

def r_squared(y, y_hat):
    y_bar = y.mean()
    ss_tot = ((y-y_bar)**2).sum()
    ss_res = ((y-y_hat)**2).sum()
    return 1 - (ss_res/ss_tot)

จากแหล่ง scipy.stats.linregress พวกเขาใช้วิธีการหาผลรวมเฉลี่ยของกำลังสอง

import numpy as np

x = np.array(x)
y = np.array(y)

# average sum of squares:
ssxm, ssxym, ssyxm, ssym = np.cov(x, y, bias=1).flat

r_num = ssxym
r_den = np.sqrt(ssxm * ssym)
r = r_num / r_den

if r_den == 0.0:
    r = 0.0
else:
    r = r_num / r_den

    if r > 1.0:
        r = 1.0
    elif r < -1.0:
        r = -1.0

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

from scipy.stats import linregress
import numpy as np

x = np.array([1,2,3,4,5,6])
y = np.array([2,3,5,6,7,8])

p3 = np.polyfit(x,y,3) # 3rd degree polynomial, you can change it to any degree you want
xp = np.linspace(1,6,6)  # 6 means the length of the line
poly_arr = np.polyval(p3,xp)

poly_list = [round(num, 3) for num in list(poly_arr)]
slope, intercept, r_value, p_value, std_err = linregress(x, poly_list)
print(r_value**2)