वेक्टर ऑपरेशन के आधार पर स्टोकेस्टिक ग्रेडिएंट वंश?

Question

चलो मान लेते हैं कि मैं एन सैंपल वाले डेटासेट का उपयोग करके स्टोचैस्टिक ग्रेडिएंट डिसेंट रिग्रेस एल्गोरिथ्म को प्रशिक्षित करना चाहता हूं। चूंकि डेटासेट का आकार तय हो चुका है, इसलिए मैं डेटा T का पुनः उपयोग करूंगा। प्रत्येक पुनरावृत्ति या "युग" में, मैं प्रत्येक प्रशिक्षण नमूने का उपयोग एक बार पूरी तरह से यादृच्छिक रूप से पूरे प्रशिक्षण सेट को पुनः व्यवस्थित करने के बाद करता हूं।

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

क्या कोई स्टोकेस्टिक क्रमिक वंश के किसी भी वेक्टरकृत कार्यान्वयन को जानता है?

संपादित करें : मुझसे पूछा गया है कि अगर मेरे डेटासेट का आकार तय हो तो मैं ऑनलाइन ग्रेडिएंट डिसेंट का उपयोग क्यों करना चाहूंगा।

[1] से, कोई यह देख सकता है कि ऑनलाइन ग्रेडिएंट डिसेंट कम से कम एम्पिरियर कॉस्ट के लिए बैच ग्रेडिएंट डिसेंट की तुलना में धीमे को परिवर्तित करता है। हालांकि, यह अपेक्षित लागत के न्यूनतम में तेजी से परिवर्तित होता है, जो सामान्यीकरण प्रदर्शन को मापता है। मैं अपनी विशिष्ट समस्या में इन सैद्धांतिक परिणामों के प्रभाव का परीक्षण करना चाहता हूं, क्रॉस सत्यापन के माध्यम से। वेक्टर किए गए कार्यान्वयन के बिना, मेरा ऑनलाइन ग्रेडिएंट डीसेंट कोड बैच ग्रेडिएंट डीसेंट एक की तुलना में बहुत धीमा है। यह उल्लेखनीय रूप से क्रॉस सत्यापन प्रक्रिया को पूरा करने में लगने वाले समय को बढ़ाता है।

संपादित करें : मैं यहाँ मेरे ऑन-लाइन ढाल वंश कार्यान्वयन के छद्म कोड को शामिल करता हूं, जैसा कि फिस्ट द्वारा अनुरोध किया गया है। मैं एक प्रतिगमन समस्या हल कर रहा हूं।

Method: on-line gradient descent (regression)
Input: X (nxp matrix; each line contains a training sample, represented as a length-p vector), Y (length-n vector; output of the training samples)
Output: A (length-p+1 vector of coefficients)

Initialize coefficients (assign value 0 to all coefficients)
Calculate outputs F
prev_error = inf
error = sum((F-Y)^2)/n
it = 0
while abs(error - prev_error)>ERROR_THRESHOLD and it<=MAX_ITERATIONS:
    Randomly shuffle training samples
    for each training sample i:
        Compute error for training sample i
        Update coefficients based on the error above
    prev_error = error
    Calculate outputs F
    error = sum((F-Y)^2)/n
    it = it + 1

[१] "लार्ज स्केल ऑनलाइन लर्निंग", एल। बॉटौ, वाई। ले। क्यूएनएन, एनआईपीएस २००३।

Comments

मिनी-बैचों में डेटासेट विभाजित करें और प्रत्येक मिनी-बैच को क्रमिक रूप से फिट करें।

— 13

साभार @ffriend हालाँकि, यह एक शुद्ध ऑन-लाइन कार्यान्वयन नहीं होगा।

— पाब्लो सूआ

यदि आपका डेटासेट ठीक है तो "शुद्ध ऑनलाइन" कार्यान्वयन का उपयोग करने का क्या कारण है? SGD केवल यह कहता है कि आपको एक बार में पूरे डेटासेट को पुनरावृत्त करने की आवश्यकता नहीं है, लेकिन इसे टुकड़ों की एक मनमानी संख्या (मिनी-बैच) में विभाजित कर सकते हैं और उन्हें एक-एक करके संसाधित कर सकते हैं। आकार 1 का मिनी-बैच केवल तभी समझ में आता है जब आपके पास डेटा का निरंतर और संभवतः अंतहीन स्रोत होता है (जैसे ट्विटर फीड, उदाहरण के लिए) और प्रत्येक नए अवलोकन के बाद मॉडल को अपडेट करना चाहते हैं। लेकिन यह बहुत दुर्लभ मामला है और निश्चित रूप से निश्चित डेटासेट के लिए नहीं है।

— प्रातः

मेरी बहुत देर से प्रतिक्रिया के लिए क्षमा याचना। कृपया, मूल प्रश्न में मेरे द्वारा जोड़ा गया पाठ देखें।

— पाब्लो सू की

क्या आप अपना कार्यान्वयन दिखा सकते हैं? मुझे गलतफहमी दिखाई देती है, लेकिन कोड नमूने के बिना इसे समझाना मुश्किल होगा।

— 8

Answer 1

सबसे पहले, शब्द "नमूना" का उपयोग आम तौर पर आबादी के सबसेट का वर्णन करने के लिए किया जाता है , इसलिए मैं "उदाहरण" के रूप में एक ही बात का उल्लेख करूंगा।

इस लाइन के कारण आपका SGD कार्यान्वयन धीमा है:

for each training example i:

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

हालाँकि, आप मिनी-बैचेस का उपयोग करके लगभग वास्तविक SGD का अनुमान लगा सकते हैं । मिनी-बैच मूल डेटासेट का एक छोटा उपसमूह है (कहते हैं, 100 उदाहरण)। आप मिनी-बैचों के आधार पर त्रुटि और पैरामीटर अपडेट की गणना करते हैं, लेकिन आप अभी भी वैश्विक अनुकूलन के बिना उनमें से कई पर पुनरावृति करते हैं, जिससे प्रक्रिया स्टोचस्टिक हो जाती है। इसलिए, अपने कार्यान्वयन को बहुत तेज़ बनाने के लिए पिछली पंक्ति को बदलने के लिए यह पर्याप्त है:

batches = split dataset into mini-batches
for batch in batches: 

और बैच से त्रुटि की गणना करें, एक उदाहरण से नहीं।

हालांकि स्पष्ट रूप से, मुझे प्रति-उदाहरण स्तर पर वेक्टरकरण का भी उल्लेख करना चाहिए। इसके बजाय, ऐसा कुछ है:

theta = np.array([...])  # parameter vector
x = np.array([...])      # example
y = 0                    # predicted response
for i in range(len(example)):
    y += x[i] * theta[i]
error = (true_y - y) ** 2  # true_y - true value of response

आपको निश्चित रूप से ऐसा कुछ करना चाहिए:

error = (true_y - sum(np.dot(x, theta))) ** 2

जो, फिर से, मिनी-बैचों के लिए सामान्यीकृत करना आसान है:

true_y = np.array([...])     # vector of response values
X = np.array([[...], [...]]) # mini-batch
errors = true_y - sum(np.dot(X, theta), 1)
error = sum(e ** 2 for e in errors)

Comments

मुझे लगता है कि यह जाने का रास्ता है। एक अच्छी तरह से चुने हुए आकार के साथ मिनी-बैच वास्तव में बैच या ऑनलाइन संस्करण की तुलना में तेजी से परिवर्तित हो सकते हैं (पूर्व पूरे सेट के अनुसार केवल एक बार अपडेट होता है, और बाद में वेक्टर नहीं किया जा सकता है, प्लस में अतिरिक्त वजन अपडेट चरण हैं)

— नील स्लेटर

तुम दोनों को धन्यवाद। पहले मिनी बैचों को सख्ती से खारिज करने के लिए माफी, लेकिन मैं अभिसरण दर पर इस पद्धति के निहितार्थ के बारे में अनिश्चित था। नील, क्या आपका अनुभव आपके खुद के अनुभव से आ रहा है, या कोई सैद्धांतिक / अनुभवजन्य प्रकाशित परिणाम हैं?

— पाब्लो सू की

@PabloSuau आप एंड्रयू एनजी के मशीन लर्निंग क्लास को कसेरा, 10 सप्ताह पर जांच सकते हैं, वह बताते हैं कि कनवर्जेन्स डब्ल्यूडब्ल्यूडी और बैच जीडी दोनों से तेज क्यों हो सकता है। अधिक सटीक होने के लिए: यह हमेशा एसडब्ल्यूडी के समान तेज होना चाहिए, लेकिन कभी-कभी यह अभ्यास में भी तेज होना चाहिए।

— विस्तृत

Answer 2

Scikit के SGD क्लासिफायरियर के आंशिक_फिट विधि की जाँच करें । आपके पास इस पर नियंत्रण है कि आप इसके साथ क्या कहते हैं: आप इसे एक बार में एक उदाहरण से पारित करके "सही" ऑनलाइन शिक्षण कर सकते हैं, या यदि आपके सभी डेटा एक सरणी में उपलब्ध हैं, तो आप मिनी-बैचों में उदाहरणों को बैच सकते हैं। यदि वे हैं, तो आप मिनीबच प्रदान करने के लिए ऐरे को स्लाइस कर सकते हैं।