जीपीयू पर अनियंत्रित nonlinear अनुकूलन समस्याओं का समाधान


18

मैं GPU (CUDA) पर कुछ अप्रतिबंधित नॉनलाइनर अनुकूलन समस्याओं को हल करने का प्रयास कर रहा हूं।

ऑब्जेक्टिव फंक्शन एक सुस्पष्ट नॉनलाइनियर फ़ंक्शन है, और इसकी ढाल विश्लेषणात्मक रूप से गणना करने के लिए अपेक्षाकृत सस्ती है, इसलिए मुझे संख्यात्मक सन्निकटन के साथ परेशान करने की आवश्यकता नहीं है।

मैं ज्यादातर fp32 मैथ्स ऑप (विभिन्न कारणों से) के साथ इस समस्या को हल करना चाहता हूं, ताकि राउंड-अप त्रुटियों के खिलाफ नॉनलाइनियर ऑप्टिमाइज़ेशन विधि अधिक मजबूत हो, जबकि अच्छा प्रदर्शन हो? (जैसे संयुग्म ढाल / अर्ध न्यूटन / ट्रस्ट क्षेत्र), क्या किसी ने अच्छे परिणाम के साथ GPU पर BFGS की कोशिश की है?

बीटीडब्ल्यू, हेसियन, यदि आवश्यक हो, तो मेरे मामले में अपेक्षाकृत छोटा है (<64x64 आमतौर पर), लेकिन मुझे इनमें से हजारों छोटे पैमाने पर अनुकूलन समस्याओं को हल करना होगा।


4
आपकी समस्याओं के छोटे आकार को देखते हुए मुझे नहीं लगता कि एल्गोरिथम की विशिष्ट पसंद (जैसे, BFGS) आपकी सबसे महत्वपूर्ण चुनौती होगी। इसके बजाय, यह GPU को कम किया जाएगा <-> सीपीयू संचार ओवरहेड। संभवतः ऐसा करने का सबसे अच्छा तरीका है कि आप GPU पर समानांतर में अपनी समस्याओं के बहुत सारे उदाहरणों को हल करने जा रहे हैं। उन सभी को एक साथ लोड करें, उन सभी को एक बार में हल करें, सभी परिणाम एक साथ डाउनलोड करें। एल्गोरिथ्म पर मेरी विशेष सलाह नहीं है, लेकिन मैं कहूंगा कि GPU शाखाओं के साथ छोरों के साथ बेहतर हैं।
माइकल ग्रांट

1
@ मिचेल सी। ग्रांट: ठीक है, संचार ओवरहेड को मेरे मामले में आसानी से गणना द्वारा छिपाया जा सकता है, इसलिए यह वहां कोई अड़चन नहीं है, मैं यहां सीमित-मेमोरी बीएफजीएस या मानक बीएफजीएस का उपयोग करने के लिए बहुत इच्छुक हूं, लेकिन यकीन है कि अगर वहाँ हैं बेहतर दृष्टिकोण।
user0002128

कुछ लोगों ने CUDA के साथ LBFGS को लागू किया
BenC

जवाबों:


8

मैंने GPU पर गैर-रैखिक सॉल्वरों की एक विस्तृत विविधता को लागू किया है, जिसमें LBFGS, Barzilai Borwein ढाल मूल और गैर-रैखिक संयुग्म ढाल शामिल हैं।

इसके लिए, दाई और युआन का गैर-रेखीय संयुग्म ढाल सबसे अधिक कुशल रहा है। सामान्य तौर पर, nonlinear संयुग्म ढाल के अन्य संस्करण अधिक कुशल हो सकते हैं (जैसे कि CG-DESCENT), लेकिन इसे लागू करने के लिए मुश्किल भी हो सकता है।

एलबीएफजीएस सामान्य रूप से एक बहुत ही ठोस विकल्प है, और जब तक आप वास्तव में स्मृति के लिए बंधे नहीं होते हैं, यह शायद शुरू करने के लिए सबसे अच्छी जगह है।

दोनों संयुग्म ढाल और BFGS को लाइन खोज की आवश्यकता होती है, जो कि जहां fp32 एक समस्या बन जाती है। लाइन खोज के लिए मानक वोल्फ स्थितियों का उपयोग करने के बजाय, मैं यहां सुझाए गए अनुमानित वुल्फ स्थिति का उपयोग करने का सुझाव दूंगा । कागज थोड़ा शामिल है, लेकिन महत्वपूर्ण सामान समीकरण 4.1 है। अनिवार्य रूप से वे स्पष्ट रूप से सटीक परिचय देते हैं जिसके साथ आप अपने फ़ंक्शन की गणना कर सकते हैं।

GPU के लिए विचार:

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

यदि यह कोई विकल्प नहीं है, तो मैं LBFGS सॉल्वर के साथ जाऊंगा। यदि आपका कार्य अच्छी तरह से व्यवहार किया गया है, तो आप केवल 1 के एक चरण आकार (लाइन खोज से बचने) का उपयोग करके दूर हो सकते हैं और निश्चित संख्या में पुनरावृत्तियों के लिए सभी समस्याओं को चला सकते हैं।


0

मैं आपको लेवेनबर्ग मार्क्वर्ट (एक ट्रस्ट क्षेत्र संस्करण) का उपयोग करने का सुझाव देता हूं क्योंकि यह कई व्यावहारिक अनुप्रयोगों में उपयोग किया जाता है और बहुत अच्छी गति-बनाम-सटीकता प्रदर्शन का प्रदर्शन करता है। इसके अलावा, GPU के लिए कुछ पुस्तकालय हैं (उदाहरण के लिए cuLM https://github.com/zitmen/cuLM ), जिन्हें आप आज़मा सकते हैं। यदि वे काम नहीं करते हैं, तो आपके लिए लागू करने के लिए बहुत सारे संसाधन हैं। एलएम को लागू करना कठिन नहीं है। आपको केवल GPU संचार को कम करने के बारे में ध्यान रखना चाहिए। एक संक्षिप्त विचार प्राप्त करने के लिए:

http://on-demand.gputechconf.com/gtc/2012/presentations/S0231-Levenberg-Marquardt-Using-Block-Sparse-Matrices-on-CUDA.pdf


2
लेवेनबर्ग-मार्क्वार्ट नॉनलाइनियर कम से कम वर्गों के लिए है। मुझे नहीं लगता कि उसने कम से कम वर्गों के बारे में कुछ भी उल्लेख किया है।
कर्ट

0

हो सकता है कि एक नकली एनालिंग प्रक्रिया राउंड-ऑफ त्रुटियों को बेहतर ढंग से संभाल सकती है (और आसानी से समानांतर हो)।

आप खोज क्षेत्र के एक कच्चे ग्रिड और एक प्रारंभिक "तापमान" पैरामीटर के साथ शुरू करते हैं

प्रत्येक चरण पर आप पॉसिबल सॉल्यूशन पॉइंट्स की गणना करते हैं (एक गैर-सॉल्यूशन पॉइंट्स को भी स्वीकार कर सकते हैं, कुछ प्रायिकता के साथ तापमान के विपरीत)

फिर उस कदम पर केवल समाधान बनाए रखें और उस तापमान को बढ़ाएं जो अगले पुनरावृत्ति के लिए अधिक महीन दाने वाला ग्रिड प्रदान करता है

तापमान तक ऐसा करें <सटीकता की सीमा / सीमा

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.