बड़े डेटा सेट के लिए ढाल मूल अक्षम क्यों है?

13

मान लें कि हमारे डेटा सेट में 1 मिलियन उदाहरण हैं, अर्थात, , और हम इन डेटा सेट पर लॉजिस्टिक या रैखिक प्रतिगमन करने के लिए ढाल वंश का उपयोग करना चाहते हैं। $x_1, \ldots, x_{10^6}$

यह ढाल मूल विधि के साथ क्या है जो इसे अक्षम बनाता है?

याद रखें कि समय पर ढाल मूल कदम निम्न द्वारा दिया गया है: $t$

w_{t + 1} = w_{t} + η_{t} \nabla f (x)

$w_{t+1} = w_{t} + \eta_t \nabla f(x)$

जहां नुकसान समारोह है। $f$

मैं उपरोक्त कदम के साथ सामान्य से कुछ भी नहीं देख रहा हूं जो एल्गोरिथ्म को अक्षम बनाता है। यह की गणना है ? क्या यह ऑपरेशन पूर्व-संगणित नहीं किया जा सकता है, अर्थात, प्रत्येक पहले से ही गणना की गई है, और बस प्रत्येक डेटा बिंदु पर उनका मूल्यांकन करें $\nabla f(x)$ $\frac{\partial f}{\partial x}$ $x_i?$

machine-learning gradient-descent large-data

— कार्लोस - द मानगो - डेंजर
स्रोत

1

अक्षम रिश्तेदार ...? यहां तक कि एक बड़े डेटासेट के लिए कम से कम वर्गों में अक्षम। एल्गोरिथ्म में क्या करता है, इसके बारे में सार्थक विचार रखने के लिए आपको बड़े ओ नोटेशन की आवश्यकता है। सभी GD एल्गोरिदम में एक ही बड़ा O नहीं है (क्या वे?)

n

$n$

— AdamO

7

यदि आप इस दावे को एक संदर्भ प्रदान करते हैं कि ढाल मूल अक्षम है तो यह मदद करेगा। क्या करने के लिए अक्षम रिश्तेदार?

मुझे लगता है कि यहाँ गायब संदर्भ मशीन लर्निंग में स्टोचैस्टिक या बैच ग्रैडिएंट डिसेंट की तुलना है। इस संदर्भ में प्रश्न का उत्तर कैसे दिया जाए। आप मॉडल के मापदंडों का अनुकूलन कर रहे हैं, यहां तक कि हाइपरपरमेटर्स भी। तो, आपके पास लागत फ़ंक्शन , जहां - आपका डेटा, और - मापदंडों का वेक्टर, और - हानि फ़ंक्शन है। इस लागत को कम करने के लिए आप पैरामीटर्स पर the ढाल का उपयोग करते हैं : $\sum_{i=1}^n L(x_i|\Theta)$ $x_i$ $\Theta$ $L()$ $\theta_j$

\frac{\partial}{\partial θ_{j}} \sum_{i = 1}^{n} L (Θ | x_{i})

$\frac{\partial}{\partial \theta_j}\sum_{i=1}^nL(\Theta|x_i)$

तो, आप देखते हैं कि आपको सभी डेटा पर योग प्राप्त करने की आवश्यकता है । यह दुर्भाग्यपूर्ण है, क्योंकि इसका मतलब है कि आप अपने ढाल वंश के प्रत्येक चरण के लिए डेटा के माध्यम से लूपिंग करते रहते हैं। यह है कि बैच और स्टोकेस्टिक ग्रेडिएंट वंश कैसे आता है: क्या होगा यदि हमने डेटा सेट से नमूना लिया, और एक नमूने पर ग्रेडिएंट की गणना की, न कि पूर्ण सेट? यहाँ, नमूना में टिप्पणियों की संख्या है । इसलिए, यदि आपका नमूना कुल सेट का 1/100 वां है, तो आप अपनी गणना को 100 गुना तेज कर देते हैं! जाहिर है, यह शोर का परिचय देता है, जो सीखने को लंबा करता है, लेकिन दर से शोर कम हो जाता है $x_{i=1,\dots,n}$

\frac{\partial}{\partial θ_{j}} \sum_{k = 1}^{n_{s}} L (Θ | x_{k})

$\frac{\partial}{\partial \theta_j}\sum_{k=1}^{n_s}L(\Theta|x_k)$

n_{s}

$n_s$

s

$s$

\sqrt{n}

$\sqrt n$ जबकि पर गणना की मात्रा बढ़ जाती है , इसलिए यह चाल काम कर सकती है।

n

$n$

वैकल्पिक रूप से, इसके बजाय पूर्ण योग तक प्रतीक्षा की जाती है, आप इसे बैचों में विभाजित कर सकते हैं, और प्रत्येक बैच लिए एक चरण करें । इस तरह से आपने M चरणों को पूरे डेटा सेट की गणना के समय तक कर लिया होगा। ये शोर करने वाले कदम होंगे, लेकिन समय के साथ शोर रद्द हो जाता है। $\sum_{i=1}^n$ $\sum_{s=1}^M\sum_{i_s=1}^{n_s}$

— Aksakal
स्रोत

19

ऐसे दो तरीके हैं जिनमें ढाल मूल अक्षम हो सकता है। दिलचस्प है, वे प्रत्येक को ठीक करने के लिए अपनी विधि का नेतृत्व करते हैं, जो लगभग विपरीत समाधान हैं। दो समस्याएं हैं:

(1) बहुत अधिक क्रमिक वंश अद्यतन आवश्यक हैं।

(2) प्रत्येक ढाल वंश कदम बहुत महंगा है।

(1) के संबंध में, दूसरे क्रम के डेरिवेटिव के बारे में जानकारी लेने वाले तरीकों के साथ ढाल वंश की तुलना करते हुए, प्रत्येक मूल में नुकसान को सुधारने के संबंध में ढाल वंश अत्यधिक अक्षम हो जाता है। एक बहुत ही मानक विधि, न्यूटन की विधि , आमतौर पर अभिसरण करने के लिए बहुत कम पुनरावृत्तियों को लेती है, अर्थात लॉजिस्टिक प्रतिगमन के लिए, न्यूटन की विधि के 10 पुनरावृत्तियों में अक्सर ढाल वंश के 5,000 पुनरावृत्तियों द्वारा प्रदान किए गए समाधान की तुलना में कम नुकसान होगा। रैखिक प्रतिगमन के लिए, यह और भी चरम है; एक बंद फार्म समाधान है! हालाँकि, जैसा कि भविष्यवक्ताओं की संख्या बहुत बड़ी हो जाती है (यानी 500+), रैखिक प्रतिगमन के लिए न्यूटन की विधि / सीधे हल करना प्रति चलना बहुत महंगा हो सकता है मैट्रिक्स संचालन की मात्रा की आवश्यकता के कारण, जबकि ढाल वंश में प्रति पुनरावृत्ति की लागत काफी कम होगी।

(2) के संबंध में, इतने बड़े डेटासेट होना संभव है कि ढाल वंश के प्रत्येक पुनरावृत्ति गणना के लिए बहुत महंगा है। ढाल की गणना करने के लिए संचालन ( = नमूना आकार, = कोवरिएट्स की संख्या) की आवश्यकता होगी। जबकि मानों के लिए आधुनिक कंप्यूटर पर बिल्कुल भी समस्या नहीं है , निश्चित रूप से , जैसी कोई चीज होगी। इस मामले में, डेटा के छोटे सबसेट के आधार पर व्युत्पन्न को अनुमानित करने वाले तरीके अधिक आकर्षक होते हैं, जैसे स्टोचस्टिक ग्रेडिएंट डिसेंट । $O(nk)$ $n$ $k$ $n = 10^{6}$ $k < 100$ $n = 10^{12}$ $k = 10^3$

मैं कहता हूं कि ये सुधार लगभग विपरीत हैं, ऐसे में न्यूटन का तरीका कुछ अधिक महंगा है, लेकिन अधिक कुशल (नुकसान के रूप में नुकसान के संदर्भ में) प्रति अपडेट, जबकि स्टोचस्टिक ग्रेडिएंट डिसेंट वास्तव में कम कुशल है, लेकिन प्रति अद्यतन बहुत कम्प्यूटेशनल सस्ता है।

— क्लिफ एबी
स्रोत

अद्भुत जवाब के लिए धन्यवाद। क्या आप को kovariates की संख्या = मतलब है ? मैं इस शब्दावली से परिचित नहीं हूं

k

$k$

— कार्लोस - द मोंगोस - डेंजर

2

@Learningonepageatatime: covariates = पूर्वसूचक चर।

— क्लिफ एबी

10

पहले मुझे आपके नोटेशन में सुधार का सुझाव दें। विशेष रूप से, चलो बजाय द्वारा नुकसान फ़ंक्शन को दर्शाते हैं । अक्षर का उपयोग करना मेरी व्यक्तिगत पसंद है क्योंकि यह मुझे याद दिलाता है कि हम L oss के साथ काम कर रहे हैं । अधिक ठोस परिवर्तन यह स्पष्ट कर रहा है कि नुकसान डेटा बजाय भार का एक कार्य है । महत्वपूर्ण बात, ग्रेडिएंट नहीं संबंध में है । So जहां आपकी है डेटा। $L(w)$ $f(x)$ $L$ $w$ $x$ $w$ $x$

\nabla L (w) = (\frac{\partial L}{\partial w_{1}}, \dots, \frac{\partial L}{\partial w_{D}}),

$\nabla L(w) = \left(\frac{\partial L}{\partial w_1}, \dots, \frac{\partial L}{\partial w_D} \right),$

D

$D$

इस तथ्य के बावजूद कि हमें भार एक फ़ंक्शन के रूप में नुकसान के बारे में सोचना चाहिए , कोई भी उचित नुकसान फ़ंक्शन अभी भी संपूर्ण डेटासेट पर निर्भर करेगा (यदि ऐसा नहीं हुआ, तो डेटा से कुछ भी सीखना संभव नहीं होगा! )। उदाहरण के लिए, रैखिक प्रतिगमन में, हम आम तौर पर सम-से-वर्ग हानि फ़ंक्शन तो ढाल का मूल्यांकन वजन के एक विशेष सेट के लिए सब कुछ खत्म राशि की आवश्यकता होगी में डाटासेट अंक । यदि , तो ढाल वंश अनुकूलन के प्रत्येक वृद्धिशील कदम को एक लाख संचालन के आदेश की आवश्यकता होगी, जो काफी महंगा है। $w$ $x$

L (w) = \sum_{i = 1}^{N} (y_{i} - w^{T} x_{i})^{2} .

$L(w) = \sum_{i=1}^N (y_i - w^Tx_i)^2.$

\nabla L (w)

$\nabla L(w)$

w

$w$

N

$N$

x

$x$

N = 10^{6}

$N = 10^6$

— tddevlin
स्रोत

3

संक्षिप्त उत्तर: सभी डेटा बिंदुओं पर योग करने के लिए ढाल की गणना करना। यदि हमारे पास बड़ी मात्रा में डेटा है, तो इसमें लंबा समय लगता है।

मेरा यहाँ विस्तृत उत्तर है।

स्टोकेस्टिक ग्रेडिएंट डिसेंट्रेंट मानक ढाल डिसेंट की तुलना में समय कैसे बचा सकता है?

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

जब आप इसे सत्यापित करते हैं, तो यह आपको आश्चर्यचकित कर सकता है: 2 विशेषताओं के साथ 5 मिलियन डेटा बिंदु, रैखिक प्रतिगमन / कम से कम वर्ग को हल करने में कुछ सेकंड लगते हैं!

x=matrix(runif(1e7),ncol=2)
y=runif(5e6)
start_time <- Sys.time()
lm(y~x)
end_time <- Sys.time()
end_time - start_time
# Time difference of 4.299081 secs

— हतौ दू
स्रोत

1

यद्यपि आपके द्वारा उल्लिखित दो उदाहरण आम तौर पर उत्तल हैं, मैं गैर-उत्तल समस्याओं के बारे में एक बिंदु जोड़ूंगा। मेरी राय में दो मुख्य कारण हैं (बैच) ग्रेडिएंट डिसेंट को "अक्षम" माना जा सकता है। कार्यों के "बड़े" योग की ढाल की गणना के कम्प्यूटेशनल प्रयास के बारे में पहला बिंदु पहले से ही अन्य उत्तरों में बहुत स्पष्ट रूप से उल्लिखित किया गया है। गैर-उत्तल समस्याओं के लिए हालांकि जीडी की समस्या आम तौर पर "कम" स्थानीय न्यूनतम में अटक जाती है। वैश्विक न्यूनतम की तुलना में यह न्यूनतम बहुत खराब हो सकता है। SGD या मिनी-बैच GD को बेतरतीब ढंग से (कम से कम आंशिक रूप से) भटकने का "फायदा" है और इस तरह एक बेहतर स्थानीय न्यूनतम खोजने का मौका मिल सकता है। इस सीवी जवाब को यहां देखें । या यह अन्य सीवी पोस्ट यह स्पष्ट करना कि कैसे यादृच्छिकता फायदेमंद हो सकती है।

— Xel
स्रोत