साधारण वर्ग के गुणांक खोजने के लिए "सामान्य समीकरणों" का उपयोग क्यों नहीं किया जाता है?

Question

मैंने इस सूची को यहाँ देखा और विश्वास नहीं कर सकता था कि कम से कम वर्गों को हल करने के बहुत सारे तरीके थे। "सामान्य समीकरण" पर विकिपीडिया एक काफी सीधे आगे रास्ता लग रहा

$${\displaystyle {\begin{aligned}{\hat {\alpha }}&={\bar {y}}-{\hat {\beta }}\,{\bar {x}},\\{\hat {\beta }}&={\frac {\sum _{i=1}^{n}(x_{i}-{\bar {x}})(y_{i}-{\bar {y}})}{\sum _{i=1}^{n}(x_{i}-{\bar {x}})^{2}}}\end{aligned}}}$$

तो क्यों नहीं बस उनका उपयोग करें? मुझे लगा कि मार्क एल। स्टोन के ऊपर पहली कड़ी में एक कम्प्यूटेशनल या सटीक मुद्दा होना चाहिए जिसमें बताया गया है कि एसवीडी या क्यूआर सांख्यिकीय सॉफ्टवेयर में लोकप्रिय तरीके हैं और सामान्य समीकरण "विश्वसनीयता और संख्यात्मक सटीकता दृष्टिकोण से कठिन" हैं। हालांकि , निम्नलिखित कोड में, सामान्य समीकरण मुझे तीन लोकप्रिय अजगर कार्यों की तुलना में ~ 12 दशमलव स्थानों के लिए सटीकता दे रहे हैं: संख्यात्मक पॉलीफ़िट ; scipy का linregress ; और स्किकिट-लर्न ऑफ लीनियरग्रेडेशन ।

क्या अधिक दिलचस्प है कि सामान्य समीकरण विधि सबसे तेज है जब n = 100000000। मेरे लिए कम्प्यूटेशनल समय हैं: रेखीय प्रगति के लिए 2.5; पॉलीफ़िट के लिए 12.9; LinearRegression के लिए 4.2 s; और सामान्य समीकरण के लिए 1.8 s।

कोड:

import numpy as np
from sklearn.linear_model import LinearRegression
from scipy.stats import linregress
import timeit

b0 = 0
b1 = 1
n = 100000000
x = np.linspace(-5, 5, n)
np.random.seed(42)
e = np.random.randn(n)
y = b0 + b1*x + e

# scipy                                                                                                                                     
start = timeit.default_timer()
print(str.format('{0:.30f}', linregress(x, y)[0]))
stop = timeit.default_timer()
print(stop - start)

# numpy                                                                                                                                      
start = timeit.default_timer()
print(str.format('{0:.30f}', np.polyfit(x, y, 1)[0]))
stop = timeit.default_timer()
print(stop - start)

# sklearn                                                                                                                                    
clf = LinearRegression()
start = timeit.default_timer()
clf.fit(x.reshape(-1, 1), y.reshape(-1, 1))
stop = timeit.default_timer()
print(str.format('{0:.30f}', clf.coef_[0, 0]))
print(stop - start)

# normal equation                                                                                                                            
start = timeit.default_timer()
slope = np.sum((x-x.mean())*(y-y.mean()))/np.sum((x-x.mean())**2)
stop = timeit.default_timer()
print(str.format('{0:.30f}', slope))
print(stop - start) 

Comments

जवाब काफी अतिरंजित हैं। यह इतना भयानक नहीं है अगर आप केवल उलटे की गणना करने से बचें।

— मैथ्रेडलर

गति पर कुछ नोट्स: आप केवल एक ही कोवरिएट को देख रहे हैं, इसलिए मैट्रिक्स व्युत्क्रम की लागत आवश्यक रूप से 0. है। यदि आप कुछ हज़ार कोवरिएट्स को देखते हैं, तो यह बदल जाएगा। दूसरा, क्योंकि आपके पास केवल एक ही सहसंयोजक है, डेटा-मुंगिंग वह है जो वास्तव में पैक किए गए प्रतियोगियों में आपका बहुत समय लेता है (लेकिन यह केवल रैखिक रूप से मापना चाहिए, इसलिए एक बड़ा सौदा नहीं है)। सामान्य समीकरणों का समाधान डेटा मुंगिंग नहीं करता है, इसलिए यह तेज़ है, लेकिन इसके परिणामों से जुड़ी कोई घंटी और सीटी नहीं है।

— क्लिफ एबी

Answer 1

$Ax \approx b$$A$$A^TA$$log_{10}(cond)$$A^TA$$A^TAx = A^Tb$$log_{10}(cond(A^TA)) = 2*log_{10}(cond(A))$

$10^8$$10^{16}$

कभी-कभी आप सामान्य समीकरणों से दूर हो जाते हैं, और कभी-कभी आप नहीं करते हैं।

Comments

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

— user541686

सटीकता में अंतर के अलावा, क्या क्यूआर और सामान्य समीकरणों के बीच एक बड़ा गति अंतर भी है? क्योंकि बाद के मामले में आप हल कर रहे होंगे (X'X) -1 * X'Y, जो उलटे की वजह से धीमा है? मैं पूछता हूं क्योंकि मुझे यकीन नहीं है कि क्यूआर कैसे काम करता है, इसलिए हो सकता है कि वहां कुछ ऐसा हो जो मैट्रिक्स के रूप में धीमा हो। या विचार का एकमात्र बिंदु सटीकता हानि है?

— साइमन

@Simon खैर, जब आप सामान्य समीकरणों को हल करते हैं तो आप वास्तव में कभी उलटा मैट्रिक्स नहीं बनाते हैं, जो बहुत धीमा है। आपको मैट्रिक्स बनाना होगा$A^TA$ और वेक्टर $A^Tb$हालाँकि, और फिर आप सिस्टम को हल करते हैं।

— चींटी

Answer 2

यदि आपको केवल इस एक चर समस्या को हल करना है, तो आगे बढ़ें और सूत्र का उपयोग करें। इसमें कुछ भी गलत नहीं है। मैं आपको एक एम्बेडेड डिवाइस के लिए ASM में कोड की कुछ पंक्तियाँ लिखता हुआ देख सकता था, उदाहरण के लिए। वास्तव में, मैंने कुछ स्थितियों में इस तरह के समाधान का उपयोग किया। आपको केवल इस एक छोटी सी समस्या को हल करने के लिए बड़े सांख्यिकीय पुस्तकालयों को खींचने की आवश्यकता नहीं है।

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

Answer 3

कोई भी आधुनिक सांख्यिकीय पैकेज सामान्य समीकरणों के साथ एक रैखिक प्रतिगमन को हल नहीं करेगा। सामान्य समीकरण केवल सांख्यिकीय पुस्तकों में मौजूद हैं।

मैट्रिक्स के व्युत्क्रम की गणना करने में सामान्य समीकरणों का उपयोग नहीं किया जाना चाहिए।

रेखीय प्रतिगमन के लिए ढाल वंश का उपयोग क्यों करें, जब एक बंद-प्रपत्र गणित समाधान उपलब्ध हो?

... हालाँकि प्रत्यक्ष सामान्य समीकरण उपलब्ध है। ध्यान दें कि सामान्य समीकरण में एक मैट्रिक्स को पलटना होता है। अब एक मैट्रिक्स को इन्वर्ट करने में O (N3) की गणना होती है, जहां N, X मैट्रिक्स में पंक्तियों की संख्या यानी ऑब्जर्वेशन है। इसके अलावा, अगर X बीमार है, तो यह अनुमान में कम्प्यूटेशनल त्रुटियाँ पैदा करेगा ...