SciPy - ऑप्टिमाइज़ करें

scipy.optimize packageकई आमतौर पर इस्तेमाल किया अनुकूलन एल्गोरिदम प्रदान करता है। इस मॉड्यूल में निम्नलिखित पहलू शामिल हैं -

  • विभिन्न प्रकार के एल्गोरिदम (जैसे BFGS, Nelder-Mead simplex, Newton Conjugate Gradient, COBYLIN या SLSQP) का उपयोग करके बहुभिन्नरूपी स्केलर फ़ंक्शंस (न्यूनतम ()) के असंबंधित और विवश न्यूनतम।

  • ग्लोबल (ब्रूट-फोर्स) ऑप्टिमाइज़ेशन रूटीन (जैसे, एनील), बेसिनहोपिंग ()

  • कम से कम वर्गों (कम से कम) () और वक्र फिटिंग (कर्व_फिट ()) एल्गोरिदम

  • स्केलर यूनीवेरिटी फ़ंक्शन्स न्यूनतम (मिनिमम_स्कलर ()) और रूट फ़ाइंडर (न्यूटन ())

  • बहुभिन्नरूपी समीकरण प्रणाली सॉल्वर्स (रूट ()) एल्गोरिदम की एक किस्म का उपयोग कर (जैसे हाइब्रिड पॉवेल, लेवेनबर्ग-मार्क्वार्ड या न्यूटन-क्रायलोव जैसे बड़े पैमाने पर तरीकों)

बहुभिन्नरूपी स्केलर कार्यों के असंबंधित और विवश न्यूनतम

minimize() function में बहुभिन्नरूपी अदिश कार्यों के लिए असंबंधित और विवश न्यूनतम एल्गोरिदम को एक सामान्य इंटरफ़ेस प्रदान करता है scipy.optimize। न्यूनकरण फ़ंक्शन को प्रदर्शित करने के लिए, NN चर के रोसेनब्रोक फ़ंक्शन को कम करने की समस्या पर विचार करें -

$$f(x) = \sum_{i = 1}^{N-1} \:100(x_i - x_{i-1}^{2})$$

इस फ़ंक्शन का न्यूनतम मान 0 है, जो xi = 1 होने पर प्राप्त होता है।

नेल्डर-मीड सिम्प्लेक्स एल्गोरिथम

निम्नलिखित उदाहरण में, न्यूनतम () दिनचर्या का उपयोग किया जाता है Nelder-Mead simplex algorithm (method = 'Nelder-Mead')(विधि पैरामीटर के माध्यम से चयनित)। आइए हम निम्नलिखित उदाहरण पर विचार करें।

import numpy as np
from scipy.optimize import minimize

def rosen(x):

x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
res = minimize(rosen, x0, method='nelder-mead')

print(res.x)

उपरोक्त कार्यक्रम निम्न आउटपुट उत्पन्न करेगा।

[7.93700741e+54  -5.41692163e+53  6.28769150e+53  1.38050484e+55  -4.14751333e+54]

सिंप्लेक्स एल्गोरिथ्म शायद एक अच्छी तरह से व्यवहार किए गए फ़ंक्शन को कम करने का सबसे सरल तरीका है। इसके लिए केवल फ़ंक्शन मूल्यांकन की आवश्यकता होती है और सरल न्यूनतम समस्याओं के लिए एक अच्छा विकल्प है। हालाँकि, क्योंकि यह किसी भी क्रमिक मूल्यांकन का उपयोग नहीं करता है, इसलिए न्यूनतम खोजने में अधिक समय लग सकता है।

एक और अनुकूलन एल्गोरिथ्म जो न्यूनतम खोजने के लिए केवल फ़ंक्शन कॉल की आवश्यकता है Powell‘s method, जो न्यूनतम () फ़ंक्शन में विधि = 'पॉवेल' को सेट करके उपलब्ध है।

कम से कम दो गुना

वैरिएबल पर सीमा के साथ एक गैर-रेखीय न्यूनतम-वर्ग समस्या को हल करें। अवशेषों f (x) (n वास्तविक चर का एक m- आयामी वास्तविक कार्य) और नुकसान फ़ंक्शन rho (s) (एक अदिश कार्य) को देखते हुए, कम से कम लागत फ़ंक्शन F (x) का एक स्थानीय न्यूनतम पाते हैं। आइए हम निम्नलिखित उदाहरण पर विचार करें।

इस उदाहरण में, हम स्वतंत्र चर पर सीमा के बिना रोसेनब्रोक फ़ंक्शन का एक न्यूनतम पाते हैं।

#Rosenbrock Function
def fun_rosenbrock(x):
   return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
   
from scipy.optimize import least_squares
input = np.array([2, 2])
res = least_squares(fun_rosenbrock, input)

print res

ध्यान दें कि, हम केवल अवशेषों का सदिश प्रदान करते हैं। एल्गोरिथ्म अवशिष्ट के वर्गों के योग के रूप में लागत फ़ंक्शन का निर्माण करता है, जो रोसेनब्रॉक फ़ंक्शन देता है। सटीक न्यूनतम x = [1.0,1.0] पर है।

उपरोक्त कार्यक्रम निम्न आउटपुट उत्पन्न करेगा।

active_mask: array([ 0., 0.])
      cost: 9.8669242910846867e-30
      fun: array([ 4.44089210e-15, 1.11022302e-16])
      grad: array([ -8.89288649e-14, 4.44089210e-14])
      jac: array([[-20.00000015,10.],[ -1.,0.]])
   message: '`gtol` termination condition is satisfied.'
      nfev: 3
      njev: 3
   optimality: 8.8928864934219529e-14
      status: 1
      success: True
         x: array([ 1., 1.])

जड़ खोजना

आइए हम समझते हैं कि जड़ खोज विज्ञान में कैसे मदद करता है।

स्केलर कार्य करता है

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

निश्चित-बिंदु हल

किसी फ़ंक्शन के शून्य को खोजने के लिए निकटता से संबंधित समस्या एक फ़ंक्शन के निश्चित बिंदु को खोजने की समस्या है। किसी फ़ंक्शन का एक निश्चित बिंदु वह बिंदु है जिस पर फ़ंक्शन का मूल्यांकन बिंदु लौटाता है: g (x) = x। स्पष्ट रूप से निर्धारित बिंदुggf (x) = g (x) .x की जड़ है। समान रूप से, की जड़ffg (x) = f (x) + x का निश्चित_ बिंदु है। रूटीन नियत_पॉइंट एक सरल पुनरावृत्त विधि प्रदान करता है जिसका उपयोग करते हुएAitkens sequence acceleration के निश्चित बिंदु का अनुमान लगाने के लिए gg, अगर एक प्रारंभिक बिंदु दिया जाता है।

समीकरणों के समूह

का उपयोग करके गैर-रेखीय समीकरणों के एक सेट की जड़ को प्राप्त किया जा सकता है root() function। कई विधियाँ उपलब्ध हैं, जिनमें सेhybr (डिफ़ॉल्ट) और एलएम, क्रमशः का उपयोग करें hybrid method of Powell और यह Levenberg-Marquardt method MINPACK से।

निम्न उदाहरण एकल-चर ट्रांसेंडेंटल समीकरण पर विचार करता है।

x2 + 2cos(x) = 0

जिसका मूल इस प्रकार पाया जा सकता है -

import numpy as np
from scipy.optimize import root
def func(x):
   return x*2 + 2 * np.cos(x)
sol = root(func, 0.3)
print sol

उपरोक्त कार्यक्रम निम्न आउटपुट उत्पन्न करेगा।

fjac: array([[-1.]])
fun: array([ 2.22044605e-16])
message: 'The solution converged.'
   nfev: 10
   qtf: array([ -2.77644574e-12])
      r: array([-3.34722409])
   status: 1
   success: True
      x: array([-0.73908513])