scipy.optimize कार्यों पर बड़े चरणों को कैसे बल दें?

Question

मैं एक समारोह compare_images(k, a, b) कि दो 2 डी-सरणियों a और b

funcion अंदर तुलना है, मैं sigma=ka मेरे विचार करने के लिए इसके लिए आदेश में छवि a सम करने के लिए मुझे कितना चाहिए अनुमान लगाने के लिए है के साथ एक gaussian_filter लागू छवि के समान हो b

समस्या मेरी समारोह compare_images केवल विभिन्न मूल्यों वापस आ जाएगी अगर k भिन्नता 0.5 खत्म हो गया है है, और अगर मैं fmin(compare_images, init_guess, (a, b) करना यह आम तौर पर init_guess मूल्य के लिए अटक।

मेरा मानना ​​है कि समस्या fmin (और minimize) बहुत छोटे कदम है, जो मेरे मामले में compare_images के लिए ठीक उसी वापसी मान पुन: पेश है, और इसलिए विधि सोचता है कि यह पहले से ही कम से कम पाया के साथ शुरू हो जाता है। यह केवल दो बार कोशिश करेगा।

क्या fmin या scipy से कोई अन्य न्यूनतम कार्य करने के लिए कोई बड़ा तरीका नहीं है? या क्या मेरी ज़रूरत के लिए कोई उपयुक्त तरीका उपयुक्त है?

संपादित करें: मुझे एक अस्थायी समाधान मिला। सबसे पहले, जैसा कि अनुशंसित किया गया था, मैंने xtol=0.5 और fmin पर तर्क के रूप में उच्च उपयोग किया। फिर भी, मुझे अभी भी कुछ समस्याएं थीं, और कुछ बार fmininit_guess वापस आ जाएगी। मैंने फिर एक साधारण लूप बनाया ताकि fmin == init_guess, मैं एक और, यादृच्छिक init_guess उत्पन्न करूंगा और इसे फिर से कोशिश करूंगा।

यह काफी धीमा है, लेकिन अब मुझे इसे चलाने के लिए मिला है। यह मेरे सभी डेटा के लिए इसे चलाने के लिए 20 घंटे या उससे अधिक समय लेगा, लेकिन मुझे इसे फिर से करने की आवश्यकता नहीं होगी।

वैसे भी, बेहतर अभी भी एक बेहतर समाधान खोजने में रुचि रखने वालों के लिए समस्या को समझाने के लिए:

• मैं 2 छवियाँ, A और B है, कुछ वैज्ञानिक डेटा युक्त।
• A चर मूल्य के साथ कुछ डॉट्स की तरह लग रहा है (यह जिसमें प्रत्येक महत्वपूर्ण बिंदु का प्रतिनिधित्व करता है, जहां एक घटना हुई के एक मैट्रिक्स है और यह तीव्रता है)
• B एक समतल हीटमैप तरह लग रहा है (यह घटनाओं की मनाया घनत्व है)
• B ऐसा लगता है कि आपने कुछ अर्द्ध-यादृच्छिक शोर के साथ A पर एक गाऊशियन फ़िल्टर लगाया है।
• हम B को sigma से A पर एक गाऊशियन फ़िल्टर लागू करके अनुमानित कर रहे हैं। यह sigma दृश्यमान रूप से चुना गया था, लेकिन केवल छवियों के एक निश्चित वर्ग के लिए काम करता है।
• मैं प्रत्येक छवि के लिए इष्टतम sigma प्राप्त करने का प्रयास कर रहा हूं, इसलिए बाद में मुझे sigma के कुछ संबंध मिल सकते हैं और प्रत्येक छवि में ईवेंट की श्रेणी दिखाई देती है।

वैसे भी, मदद के लिए धन्यवाद!

Answer 1

त्वरित जांच: आप शायद वास्तव में fmin(compare_images, init_guess, (a,b)) मतलब था?

यदि gaussian_filter व्यवहार करता है जैसा कि आप कहते हैं, आपका कार्य टुकड़े की तरह स्थिर है, जिसका अर्थ है कि डेरिवेटिव्स (यानी उनमें से अधिकतर) पर निर्भर ऑप्टिमाइज़र बाहर हैं। आप k की समझदार रेंज पर anneal, या ब्रूट-बल खोज जैसे वैश्विक अनुकूलक को आजमा सकते हैं।

हालांकि, जैसा कि आपने समस्या का वर्णन किया है, सामान्यतः केवल compare_images का स्पष्ट, वैश्विक न्यूनतम ba का एक चिकना संस्करण है। यदि आप a की चिकनाई की मात्रा निर्धारित करना चाहते हैं तो यह दृष्टिकोण समझ में आता है जो दोनों छवियों को सबसे समान बनाता है।

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

संपादित: एक अन्य विचार है कि मदद कर सकता है: compare_images पुनर्लेखन इतना है कि यह smoothed- a के दो संस्करणों की गणना करता है - साथ सिग्मा = floor(k) एक और अगली को ceil(k) (यानी दौर कश्मीर के साथ एक निचला/उच्च int)। फिर की गणना करें, kfrack का आंशिक भाग होने के साथ। इस तरह तुलना फ़ंक्शन निरंतर w.r.t k बन जाता है।

शुभकामनाएं!

Answer 2

Basin hopping थोड़ा बेहतर कर सकता है, क्योंकि पठार में फंसने पर इसे जारी रखने का उच्च अवसर होता है।

मैं इस उदाहरण समारोह पर पाया है कि यह एक कम तापमान के साथ काफी अच्छा करता है:

>>> opt.basinhopping(lambda (x,y): int(0.1*x**2 + 0.1*y**2), (5,-5), T=.1) 
    nfev: 409 
    fun: 0 
     x: array([ 1.73267813, -2.54527514]) 
message: ['requested number of basinhopping iterations completed successfully'] 
    njev: 102 
    nit: 100