🐒 ⛹🏽 🛸 SciPy, अनुकूलन ❎ 🙏🏼 ⛏️

SciPy (स्पष्ट साई पाई) एक गणितीय अनुप्रयोग पैकेज है जो नम्पी पायथन विस्तार पर आधारित है। SciPy के साथ, एक इंटरैक्टिव पायथन सत्र MATLAB, IDL, ऑक्टेव, आर-लैब और SciLab जैसी जटिल प्रणालियों के लिए एक ही संपूर्ण डेटा प्रोसेसिंग और प्रोटोटाइपिंग वातावरण में बदल जाता है। आज मैं संक्षेप में scipy.optimize पैकेज में कुछ प्रसिद्ध अनुकूलन एल्गोरिदम का उपयोग करने के बारे में बात करना चाहता हूं। फ़ंक्शन का उपयोग करने पर अधिक विस्तृत और अद्यतित सहायता हमेशा मदद () कमांड या Shift + Tab का उपयोग करके प्राप्त की जा सकती है।

परिचय

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

तो, scipy.optimize मॉड्यूल में निम्नलिखित प्रक्रियाओं का कार्यान्वयन शामिल है:

विभिन्न एल्गोरिदम (नेल्डर-मेड सिम्प्लेक्स, बीएफजीएस, संयुग्म न्यूटन ग्रेडिएटर्स , COBYLA और SLSQP ) का उपयोग करके कई चर (न्यूनतम) के स्केलर फ़ंक्शंस की सशर्त और बिना शर्त न्यूनतमकरण
ग्लोबल ऑप्टिमाइज़ेशन (उदा: बेसिनहोपिंग , diff_evolution )
गैर-रैखिक कम से कम वर्गों (कर्व_फिट) के लिए फिटिंग घटता के लिए कम से कम वर्गों (सबसे कम वर्ग ) और एल्गोरिदम के अवशेष का न्यूनतमकरण
एक चर (मिनिमम_स्कलर) के स्केलर फ़ंक्शंस को कम करना और जड़ों (root_scalar) का पता लगाना
विभिन्न एल्गोरिदम (हाइब्रिड पॉवेल, लेवेनबर्ग-मार्क्वार्ड या बड़े पैमाने पर तरीकों, जैसे न्यूटन- क्रिलोव ) का उपयोग करके समीकरणों (रूट) की प्रणाली के बहुआयामी सॉल्वर।

इस लेख में हम इस पूरी सूची से केवल पहले आइटम पर विचार करेंगे।

कई चर के अदिश समारोह का बिना शर्त न्यूनतमकरण

Scipy.optimize पैकेज से न्यूनतम फ़ंक्शन कई चर के स्केलर फ़ंक्शंस की सशर्त और बिना शर्त न्यूनतम समस्याओं को हल करने के लिए एक सामान्य इंटरफ़ेस प्रदान करता है। इसके काम को प्रदर्शित करने के लिए, हमें कई चरों के उपयुक्त कार्य की आवश्यकता होगी, जिसे हम विभिन्न तरीकों से कम से कम करेंगे।

इन उद्देश्यों के लिए, N चरों का रोसेनब्रोक फ़ंक्शन सही है, जिसका रूप है:

$f \ left (\ mathbf {x} \ right) = \ sum_ {i = 1} ^ {N-1} [100 \ left (x_ {i + 1} -x_ {i} ^ {2} \ right) ^ {2} + \ बायां (1-x_ {i} \ right) ^ {2}]$

इस तथ्य के बावजूद कि रोसेनब्रोक फ़ंक्शन और इसके जैकोबी और हेसियन मैट्रिसेस (क्रमशः पहला और दूसरा डेरिवेटिव), पहले से ही स्काइप में हैं। पैकेज को अपनाना, हम इसे स्वयं परिभाषित करते हैं।

import numpy as np def rosen(x): """The Rosenbrock function""" return np.sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0, axis=0)

स्पष्टता के लिए, हम दो चर के रोसेनब्रोक फ़ंक्शन के मानों को 3 डी में आकर्षित करते हैं।

प्रतिपादन के लिए कोड

 from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from matplotlib import cm from matplotlib.ticker import LinearLocator, FormatStrFormatter #  3D  fig = plt.figure(figsize=[15, 10]) ax = fig.gca(projection='3d') #    ax.view_init(45, 30) #     X = np.arange(-2, 2, 0.1) Y = np.arange(-1, 3, 0.1) X, Y = np.meshgrid(X, Y) Z = rosen(np.array([X,Y])) #   surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm) plt.show()

अग्रिम में जानना कि न्यूनतम 0 के लिए है $x_i = 1$ , विभिन्न scipy.optimize प्रक्रियाओं का उपयोग करके रोसेनब्रोक फ़ंक्शन के न्यूनतम मूल्य का निर्धारण कैसे करें के उदाहरणों पर विचार करें।

नेल्डर-मीड सिम्पलेक्स विधि (नेल्डर-मीड)

5-आयामी अंतरिक्ष में एक प्रारंभिक बिंदु x0 होने दें। नेल्डर-मीड सिम्प्लेक्स एल्गोरिथ्म का उपयोग करते हुए निकटतम रोसेनब्रोक फ़ंक्शन का न्यूनतम बिंदु ढूंढें (एल्गोरिथ्म विधि पैरामीटर के मान के रूप में निर्दिष्ट है):

 from scipy.optimize import minimize x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2]) res = minimize(rosen, x0, method='nelder-mead', options={'xtol': 1e-8, 'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 339 Function evaluations: 571 [1. 1. 1. 1. 1.]

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

पावेल विधि

एक अन्य अनुकूलन एल्गोरिथ्म जिसमें केवल फ़ंक्शन मान की गणना की जाती है , पॉवेल विधि है । इसका उपयोग करने के लिए, आपको न्यूनतम फ़ंक्शन में विधि = 'पॉवेल' सेट करने की आवश्यकता है।

 x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2]) res = minimize(rosen, x0, method='powell', options={'xtol': 1e-8, 'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 19 Function evaluations: 1622 [1. 1. 1. 1. 1.]

ब्रोयडेन-फ्लेचर-गोल्डफर्ब-चन्नो एल्गोरिथम (BFGS)

समाधान के लिए तेजी से अभिसरण प्राप्त करने के लिए, BFGS प्रक्रिया उद्देश्य फ़ंक्शन के ढाल का उपयोग करती है। ग्रेडिएंट को फ़ंक्शन के रूप में निर्दिष्ट किया जा सकता है या पहले-क्रम के अंतर का उपयोग करके गणना की जा सकती है। किसी भी स्थिति में, आमतौर पर BFGS विधि को सिंपल विधि की तुलना में कम फ़ंक्शन कॉल की आवश्यकता होती है।

हम विश्लेषणात्मक रूप में रोसेनब्रोक फ़ंक्शन के व्युत्पन्न पाते हैं:

$\ frac {\ आंशिक f} {\ आंशिक x_j} = \ sum \ limit_ {i = 1} ^ N 200 (x_i - x_ {i-1} ^ 2) (\ delta_ {i, j} / 2x_ {i -1, j}) - 2 (1 - x_ {i-1}) \ delta_ {i-1, j} =$

$= 200 (x_j - x_ {j-1} ^ 2) - 400x_j (x_ {j + 1} - x_j ^ 2) - 2 (1-x_j)$

यह अभिव्यक्ति पहले और अंतिम को छोड़कर सभी चर के व्युत्पन्न के लिए मान्य है, जिन्हें इस प्रकार परिभाषित किया गया है:

$\ frac {\ आंशिक f} {\ आंशिक x_0} = -400 x_0 (x_1 - x_0 ^ 2) - 2 (1 - x_0),$

$\ frac {\ आंशिक f} {\ आंशिक x_ {N-1}} = 200 (x_ {N-1} - x_ {N-2} ^ 2)।$

आइए इस क्रमांक की गणना करने वाले पायथन फ़ंक्शन को देखें:

 def rosen_der (x): xm = x [1: -1] xm_m1 = x [: - 2] xm_p1 = x [2:] der = np.zeros_like (x) der [1: -1] = 200 * (xm-xm_m1 ** 2) - 400 * (xm_p1 - xm ** 2) * xm - 2 * (1-xm) der [0] = -400 * x [0] * (x [1] -x [0] ** 2) - 2 * (1-x [0]) der [-1] = 200 * (x [-1] -x [-2] ** 2) return der

ग्रेडिएंट गणना फ़ंक्शन न्यूनतम फ़ंक्शन के जावा पैरामीटर के मान के रूप में निर्दिष्ट किया गया है, जैसा कि नीचे दिखाया गया है।

 res = minimize(rosen, x0, method='BFGS', jac=rosen_der, options={'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 25 Function evaluations: 30 Gradient evaluations: 30 [1.00000004 1.0000001 1.00000021 1.00000044 1.00000092]

संयुग्मित स्नातक एल्गोरिथ्म (न्यूटन)

न्यूटन संयुग्मक ढाल एल्गोरिथ्म एक संशोधित न्यूटन विधि है।
न्यूटन की विधि एक स्थानीय क्षेत्र में दूसरी डिग्री के एक बहुपद द्वारा एक समारोह का अनुमान लगाने पर आधारित है:

$f \ left (\ mathbf {x} \ right) \ लगभग f \ left (\ mathbf {x} _ {0} \ right) + \ nabla f \ left (\ mathbf {x} _ {0} / दाएँ) \ cdot \ left (\ mathbf {x} - \ mathbf {x} _ {0} \ right) + \ frac {1} {2} \ left (\ mathbf {x} - \ mathbf {x} {0}) \ right) ^ {T} \ mathbf {H} \ left (\ mathbf {x} _ {0} \ right) \ left (\ mathbf {x} - \ mathbf {x} _ {0} \ right) $$

जहाँ $\ mathbf {H} \ left (\ mathbf {x} _ {0} \ right)$ दूसरा डेरिवेटिव (हेसियन मैट्रिक्स, हेसियन) का एक मैट्रिक्स है।
यदि हेसियन सकारात्मक निश्चित है, तो इस फ़ंक्शन के स्थानीय न्यूनतम को द्विघात रूपांतर के शून्य ग्रेडिएंट के बराबर करके पाया जा सकता है। परिणाम एक अभिव्यक्ति है:

$\ mathbf {x} _ {\ textrm {opt}} = \ mathbf {x} _ {0} - \ mathbf {H} ^ {- 1} \ nabla f$

उलटा हेसियन की गणना संयुग्म ढाल पद्धति का उपयोग करके की जाती है। रोसेनब्रोक फ़ंक्शन को कम करने के लिए इस पद्धति का उपयोग करने का एक उदाहरण नीचे दिया गया है। न्यूटन-सीजी पद्धति का उपयोग करने के लिए, आपको एक फ़ंक्शन को परिभाषित करना होगा जो हेसियन का मूल्यांकन करता है।
विश्लेषणात्मक रूप में रोसेनब्रोक फ़ंक्शन का हेसियन इसके बराबर है:

$H_ {i, j} = \ frac {\ आंशिक ^ 2 f} {\ आंशिक x_i x_j} = 200 (\ delta_ {i, j} - 2x_ {i-1} \ delta {i-1, j} -) 400x_i (\ delta_ {i + 1, j} - 2x_i \ delta {i, j}) - 400 \ delta_ {i, j} (x_ {i + 1} - x_i ^ 2) 2 "2 डेल्टा = {i, j } =$

$= (202 + 1200x_i ^ 2 - 400x_ {i + 1}) \ delta_ {i, j} - 400x_i \ delta_ {i + 1, j} - 400x_ {i-1} delta_ {i-1, j}$

जहाँ $i, j \ _ in [left [1, N-2 \ right]$ और $i, j \ _ in \ left [0, N-1 \ right]$ मैट्रिक्स निर्धारित करें $एन \ N बार$ ।

मैट्रिक्स के शेष नॉनज़रो तत्व इसके बराबर हैं:

$\ frac {\ आंशिक ^ 2 f} {\ आंशिक x_0 ^ 2} = 1200x_0 ^ 2 - 400x_1/2$

$\ frac {\ आंशिक ^ 2 f} {\ आंशिक x_0 x_1} = \ frac {\ आंशिक ^ 2 f} {\ आंशिक x_1 x_0} = -400x_0$

$\ frac {\ आंशिक ^ 2 f} {\ आंशिक x_ {N-1} x_ {N-2}} = \ frac {\ आंशिक ^ 2 f} {\ आंशिक x_ {N-2} x_ {N-1 }} = -400x_ {N-2}$

$\ frac {\ आंशिक ^ 2 f} {\ आंशिक x_ {N-1} ^ 2} = 200x$

उदाहरण के लिए, पांच आयामी स्थान N = 5 में, रोसेनब्रोक फ़ंक्शन के लिए हेसियन मैट्रिक्स में टेप रूप है:

$\ small \ mathbf {H} = \ start {bmatrix} 1200x_ {0} ^ {2} -400x_ {1} +2 & -400x_ {0} & 0 & 0 & 0 \\ -400x_ {0} & 202 + 1200x_ {1} ^ {2} -400x_ {2} & -400x_ {1} & 0 & 0 \\ 0 & -400x_ {1} & 202 + 1200x_ {2} ^ {2} -400x_ {3} & -400x_ {2} & 0 \\ 0 & -400x_ {2} & 202 + 1200x_ {3} ^ {2} -400x_ {4} & -400x_ {3} \\ 0 & 0 & 0 & -400x_ { 3} & 200 \ अंत {bmatrix}$

कोड जो इस हेस्सियन की गणना करता है, कोड के साथ रूजेनब्रैक फ़ंक्शन को कम करने के लिए संयुग्म ढाल विधि (न्यूटन) का उपयोग करता है:

 def rosen_hess(x): x = np.asarray(x) H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1) diagonal = np.zeros_like(x) diagonal[0] = 1200*x[0]**2-400*x[1]+2 diagonal[-1] = 200 diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:] H = H + np.diag(diagonal) return H res = minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hess=rosen_hess, options={'xtol': 1e-8, 'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 24 Function evaluations: 33 Gradient evaluations: 56 Hessian evaluations: 24 [1. 1. 1. 0.99999999 0.99999999]

हेसियन के उत्पाद के कार्य की परिभाषा और एक मनमाना वेक्टर के साथ एक उदाहरण

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

हेस फ़ंक्शन पर विचार करें, जो पहले तर्क के रूप में एक न्यूनतम वेक्टर और दूसरे तर्क के रूप में एक मनमाना वेक्टर (न्यूनतम फ़ंक्शन के अन्य तर्कों के साथ) लेता है। हमारे मामले में, एक अनियंत्रित वेक्टर के साथ रोसेनब्रोक फ़ंक्शन के हेस्सियन के उत्पाद की गणना करना बहुत मुश्किल नहीं है। यदि पी एक मनमाना वेक्टर है, तो उत्पाद $H (x) \ cdot p$ फार्म है:

$\ mathbf {H} \ left (\ mathbf {x} \ right) \ mathbf {p} = \ start {bmatrix} \ left (1200x_ {0} ^ {2} -400x_ {1} # 2 \ सही) p_ {0} -400x_ {0} p_ {1} \\ \ vdots \\ -400x_ {i-1} p_ {i-1} + \ left (202 + 1200x_ {i} ^ {2} -400x_ {i +) 1} \ right) p_ {i} -400x_ {i} p_ {i + 1} \\ \ vdots \\ -400x_ {N-2} p_ {N-2} + 200p_ {N-1 \ "{bmatrix }।$

एक फ़ंक्शन जो हेस्सियन के उत्पाद की गणना करता है और एक मनमाना वेक्टर है, जिसे न्यूनतम करने के लिए hessp तर्क के मान के रूप में पास किया जाता है:

 def rosen_hess_p(x, p): x = np.asarray(x) Hp = np.zeros_like(x) Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1] Hp[1:-1] = -400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] \ -400*x[1:-1]*p[2:] Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1] return Hp res = minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hessp=rosen_hess_p, options={'xtol': 1e-8, 'disp': True})

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 24 Function evaluations: 33 Gradient evaluations: 56 Hessian evaluations: 66

संयुग्म ग्रेडिएटर्स का विश्वास क्षेत्र एल्गोरिथ्म (न्यूटन)

हेसियन मैट्रिक्स की गलत स्थिति और गलत खोज निर्देश इस तथ्य को जन्म दे सकते हैं कि संयुग्म न्यूटन ग्रेडिएंट्स का एल्गोरिथ्म अक्षम हो सकता है। ऐसे मामलों में, प्राथमिकता न्यूटन ग्रेडिएंट्स को संयुग्मित करने के विश्वास क्षेत्र पद्धति को दी जाती है ।

हेसियन मैट्रिक्स परिभाषा उदाहरण:

 res = minimize(rosen, x0, method='trust-ncg', jac=rosen_der, hess=rosen_hess, options={'gtol': 1e-8, 'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 20 Function evaluations: 21 Gradient evaluations: 20 Hessian evaluations: 19 [1. 1. 1. 1. 1.]

हेसियन के उत्पाद समारोह और एक मनमाना वेक्टर के साथ एक उदाहरण:

 res = minimize(rosen, x0, method='trust-ncg', jac=rosen_der, hessp=rosen_hess_p, options={'gtol': 1e-8, 'disp': True}) print(res.x)

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 20 Function evaluations: 21 Gradient evaluations: 20 Hessian evaluations: 0 [1. 1. 1. 1. 1.]

क्रायलोव्स्की प्रकार के तरीके

ट्रस्ट-एनसीजी विधि की तरह, क्रिलोव्स्की-प्रकार के तरीके बड़े पैमाने पर समस्याओं को हल करने के लिए अच्छी तरह से अनुकूल हैं, क्योंकि वे केवल मैट्रिक्स-वेक्टर उत्पादों का उपयोग करते हैं। उनका सार त्रस्त क्रायलोव उप-क्षेत्र द्वारा सीमित गोपनीय क्षेत्र में समस्या को हल करने में है। अनिश्चित कार्यों के लिए, इस पद्धति का उपयोग करना बेहतर है, क्योंकि यह ट्रस्ट-एनसीजी विधि की तुलना में प्रति मैट्रिक्स में कम मैट्रिक्स-वेक्टर उत्पादों के कारण गैर-रैखिक पुनरावृत्तियों का उपयोग करता है। इसके अतिरिक्त, ट्रस्ट-एनसीजी विधि की तुलना में द्विघात उपसमूह का समाधान अधिक सटीक है।
हेसियन मैट्रिक्स परिभाषा उदाहरण:

 res = minimize(rosen, x0, method='trust-krylov', jac=rosen_der, hess=rosen_hess, options={'gtol': 1e-8, 'disp': True}) Optimization terminated successfully. Current function value: 0.000000 Iterations: 19 Function evaluations: 20 Gradient evaluations: 20 Hessian evaluations: 18 print(res.x) [1. 1. 1. 1. 1.]

हेसियन के उत्पाद समारोह और एक मनमाना वेक्टर के साथ एक उदाहरण:

 res = minimize(rosen, x0, method='trust-krylov', jac=rosen_der, hessp=rosen_hess_p, options={'gtol': 1e-8, 'disp': True}) Optimization terminated successfully. Current function value: 0.000000 Iterations: 19 Function evaluations: 20 Gradient evaluations: 20 Hessian evaluations: 0 print(res.x) [1. 1. 1. 1. 1.]

आत्मविश्वास-आधारित अनुमानित एल्गोरिदम

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

मध्यम आकार की समस्याओं में, हेसियन के भंडारण और फैक्टरिंग की लागत महत्वपूर्ण नहीं है। इसका मतलब यह है कि कम पुनरावृत्तियों में एक समाधान प्राप्त किया जा सकता है, ट्रस्ट क्षेत्र के उपशीर्षक को लगभग बिल्कुल हल करता है। इसके लिए, कुछ द्विघात समीकरणों को प्रत्येक द्विघात उपवाक्यों के लिए पुनरावृत्तीय रूप से हल किया जाता है। इस तरह के समाधान के लिए आमतौर पर होलस हेसियन मैट्रिक्स के 3 या 4 विघटन की आवश्यकता होती है। नतीजतन, विधि कम पुनरावृत्तियों में परिवर्तित हो जाती है और आत्मविश्वास डोमेन के अन्य कार्यान्वित तरीकों की तुलना में उद्देश्य फ़ंक्शन की कम गणना की आवश्यकता होती है। यह एल्गोरिथ्म केवल पूर्ण हेसियन मैट्रिक्स का निर्धारण करने का अर्थ है और हेसियन के उत्पाद फ़ंक्शन और एक मनमाना वेक्टर का उपयोग करने की क्षमता का समर्थन नहीं करता है।

रोसेनब्रॉक फ़ंक्शन को कम करने का एक उदाहरण:

 res = minimize(rosen, x0, method='trust-exact', jac=rosen_der, hess=rosen_hess, options={'gtol': 1e-8, 'disp': True}) res.x

 Optimization terminated successfully. Current function value: 0.000000 Iterations: 13 Function evaluations: 14 Gradient evaluations: 13 Hessian evaluations: 14 array([1., 1., 1., 1., 1.])

यह, शायद, निवासी। अगले लेख में मैं सशर्त न्यूनता के बारे में सबसे दिलचस्प बताने की कोशिश करूंगा, सन्निकटन समस्याओं को हल करने में न्यूनतमकरण का आवेदन, एक चर के कार्य को कम करना, मनमाने ढंग से न्यूनतम करना और स्कैपी को अपनाने वाले समीकरणों की प्रणाली की जड़ों को खोजना। पैकेज का उपयोग करें।

स्रोत: https://docs.scipy.org/doc/scipy/reference/

SciPy, अनुकूलन