Scipy.optimize: तर्क मानों को कैसे प्रतिबंधित करें

Question

मैं कई तर्कों के साथ एक जटिल कार्य के वैश्विक न्यूनतम खोजने के लिए scipy.optimize फ़ंक्शंस का उपयोग करने का प्रयास कर रहा हूं। scipy.optimize.minimize सबसे अच्छा काम करता है, अर्थात्, 'नेल्डर-मीड' विधि। हालांकि, यह तर्कों के डोमेन से बाहर क्षेत्रों में जाता है (उन तर्कों के लिए नकारात्मक मान निर्दिष्ट करने के लिए जो केवल सकारात्मक हो सकते हैं) और इस तरह ऐसे मामलों में एक त्रुटि देता है। क्या scipy.optimize.minimize फ़ंक्शन के भीतर तर्कों की सीमा प्रतिबंधित करने का कोई तरीका है? या शायद अन्य scipy.optimize कार्यों के भीतर?

पैरामीटर स्वीकार्य सीमा से बाहर गिर रहे हैं, (डेटा से दूर फिट किया जा करने के लिए) एक बेतहाशा बड़ी संख्या वापसी:

मैं निम्नलिखित सलाह मिल गया है। यह (उम्मीद है कि) पैरामीटर के इस विकल्प को दंडित करेगा कि curve_fit इष्टतम के रूप में पैरामीटर के कुछ अन्य स्वीकार्य सेट पर व्यवस्थित होगा।

given in this previous answer, लेकिन प्रक्रिया मेरे मामले में बहुत अधिक कम्प्यूटेशनल समय लेगी।

Answer 1

Nelder-मीड solver कंस्ट्रेन्ड अनुकूलन का समर्थन नहीं करता है, लेकिन वहाँ कई दूसरों है कि कर रहे हैं।

टीएनसी और एल-बीएफजीएस-बी दोनों केवल बाध्य बाधाओं का समर्थन करते हैं (उदा। x[0] >= 0), जो आपके मामले के लिए ठीक होना चाहिए। कोबला और एसएलएसक्यूपी अधिक लचीला है, सीमाओं, समानता और असमानता-आधारित बाधाओं के किसी भी संयोजन का समर्थन करते हैं।

आप स्टैंडअलोन फ़ंक्शंस के लिए दस्तावेज़ों को देखकर हलकों के बारे में अधिक विस्तृत जानकारी प्राप्त कर सकते हैं, उदा। scipy.optimize.fmin_slsqpmethod='SLSQP' के लिए।

आप एसएलएसक्यूपी का उपयोग करके सीमित ऑप्टिमाइज़ेशन के उदाहरण के लिए मेरा पिछला उत्तर here देख सकते हैं।

Answer 2

minimize फ़ंक्शन में bounds parameter है जिसका उपयोग एल-बीएफजीएस-बी, टीएनसी, कोबला या एसएलएसक्यूपी विधियों का उपयोग करते समय प्रत्येक चर के लिए सीमाओं को सीमित करने के लिए किया जा सकता है।

उदाहरण के लिए

,

import scipy.optimize as optimize 

fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 
res = optimize.minimize(fun, (2, 0), method='TNC', tol=1e-10) 
print(res.x) 
# [ 1.   2.49999999] 

bnds = ((0.25, 0.75), (0, 2.0)) 
res = optimize.minimize(fun, (2, 0), method='TNC', bounds=bnds, tol=1e-10) 
print(res.x) 
# [ 0.75 2. ] 

Answer 3

मुझे पता है कि यह खेल में देर हो चुकी है, लेकिन शायद mystic पर एक नज़र डालें। आप किसी भी अनुकूलक (scipy.optimize.fmin से एल्गोरिदम सहित) पर दंड फ़ंक्शन के रूप में मनमानी पायथन कार्यों को लागू कर सकते हैं, या सीमा बाधाओं को लागू कर सकते हैं।

https://github.com/uqfoundation/mystic

Answer 4

तर्क आप के लिए देख रहे हैं: constraints जो तर्क के लिए पारित से एक है। अपनी खुद की लैम्ब्डा समारोह है कि मानकों को प्राप्त करता है रोल इस तरह विवश करने के लिए:

#A function to define the space where scipy.minimize should 
#confine its search: 
def apply_sum_constraint(inputs): 
    #return value must come back as 0 to be accepted 
    #if return value is anything other than 0 it's rejected 
    #as not a valid answer. 
    total = 50.0 - np.sum(inputs) 
    return total 

my_constraints = ({'type': 'eq', "fun": apply_sum_constraint }) 
result = spo.minimize(f, 
         guess, 
         method='SLSQP', 
         args=(a, b, c), 
         bounds=((-1.0, 1.0), (-1.0, 1.0)), 
         options={'disp': True}, 
         constraints=my_constraints) 

ऊपर के उदाहरण का दावा है कि पिछले खोजा गया आइटम के पड़ोस में सभी नए उम्मीदवारों बेहतर 50. बदलें को जोड़ कि विधि को परिभाषित करने के अनुमत खोज स्थान और scipy.minimize फ़ंक्शन उन उत्तरों पर विचार करने के लिए कोई ऊर्जा बर्बाद नहीं करेगा।