SciPy, ઑપ્ટિમાઇઝેશન

SciPy (ઉચ્ચાર સાઈ પાઈ) એ Numpy Python એક્સ્ટેંશન પર આધારિત ગાણિતિક એપ્લિકેશન પેકેજ છે. SciPy સાથે, તમારું ઇન્ટરેક્ટિવ પાયથોન સત્ર MATLAB, IDL, Octave, R-Lab અને SciLab જેવું જ સંપૂર્ણ ડેટા વિજ્ઞાન અને જટિલ સિસ્ટમ પ્રોટોટાઇપિંગ વાતાવરણ બની જાય છે. આજે હું scipy.optimize પેકેજમાં કેટલાક જાણીતા ઓપ્ટિમાઇઝેશન એલ્ગોરિધમનો ઉપયોગ કેવી રીતે કરવો તે વિશે ટૂંકમાં વાત કરવા માંગુ છું. ફંક્શનનો ઉપયોગ કરવા પર વધુ વિગતવાર અને અદ્યતન મદદ હંમેશા help() આદેશનો ઉપયોગ કરીને અથવા Shift+Tab નો ઉપયોગ કરીને મેળવી શકાય છે.

પરિચય

પોતાને અને વાચકોને પ્રાથમિક સ્ત્રોતો શોધવા અને વાંચવાથી બચાવવા માટે, પદ્ધતિઓના વર્ણનની લિંક્સ મુખ્યત્વે વિકિપીડિયા પર હશે. એક નિયમ તરીકે, આ માહિતી સામાન્ય શરતોમાં પદ્ધતિઓ અને તેમની અરજી માટેની શરતોને સમજવા માટે પૂરતી છે. ગાણિતિક પદ્ધતિઓના સારને સમજવા માટે, વધુ અધિકૃત પ્રકાશનોની લિંક્સને અનુસરો, જે દરેક લેખના અંતે અથવા તમારા મનપસંદ શોધ એન્જિનમાં મળી શકે છે.

તેથી, scipy.optimize મોડ્યુલમાં નીચેની પ્રક્રિયાઓના અમલીકરણનો સમાવેશ થાય છે:

1. વિવિધ અલ્ગોરિધમ્સ (નેલ્ડર-મીડ સિમ્પ્લેક્સ, BFGS, ન્યૂટન કન્જુગેટ ગ્રેડિયન્ટ્સ, કોબીલા и SLSQP)
2. વૈશ્વિક ઓપ્ટિમાઇઝેશન (ઉદાહરણ તરીકે: બેસિનહોપિંગ, તફાવત_વિકાસ)
3. અવશેષો ઘટાડવા MNC (ઓછામાં ઓછા_ચોરસ) અને વક્ર ફિટિંગ અલ્ગોરિધમ્સ નોનલાઇનર ન્યૂનતમ ચોરસ (વળાંક_ફિટ) નો ઉપયોગ કરીને
4. એક ચલ (મિનિમ_સ્કેલર) ના સ્કેલર ફંક્શનને ન્યૂનતમ કરવું અને મૂળ (રુટ_સ્કેલર) માટે શોધવું
5. વિવિધ અલ્ગોરિધમ્સ (સંકર પોવેલ, લેવેનબર્ગ-માર્કવાર્ટ અથવા મોટા પાયે પદ્ધતિઓ જેમ કે ન્યુટન-ક્રિલોવ).

આ લેખમાં આપણે આ સમગ્ર સૂચિમાંથી ફક્ત પ્રથમ આઇટમ પર વિચાર કરીશું.

અનેક ચલોના સ્કેલર ફંક્શનનું બિનશરતી લઘુત્તમીકરણ

scipy.optimize પેકેજમાંથી લઘુત્તમ કાર્ય ઘણા ચલોના સ્કેલર કાર્યોની શરતી અને બિનશરતી લઘુત્તમ સમસ્યાઓ હલ કરવા માટે એક સામાન્ય ઇન્ટરફેસ પ્રદાન કરે છે. તે કેવી રીતે કાર્ય કરે છે તે દર્શાવવા માટે, અમને ઘણા ચલોના યોગ્ય કાર્યની જરૂર પડશે, જેને અમે અલગ અલગ રીતે ઘટાડીશું.

આ હેતુઓ માટે, N ચલોનું રોઝનબ્રોક કાર્ય સંપૂર્ણ છે, જેનું સ્વરૂપ છે:

હકીકત એ છે કે રોસેનબ્રોક ફંક્શન અને તેના જેકોબી અને હેસિયન મેટ્રિસીસ (અનુક્રમે પ્રથમ અને બીજા ડેરિવેટિવ્ઝ) scipy.optimize પેકેજમાં પહેલેથી જ વ્યાખ્યાયિત છે, અમે તેને જાતે વ્યાખ્યાયિત કરીશું.

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)

સ્પષ્ટતા માટે, ચાલો બે ચલોના રોઝનબ્રોક ફંક્શનના મૂલ્યોને 3D માં દોરીએ.

ડ્રોઇંગ કોડ

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 પર છે , ચાલો વિવિધ scipy.optimize પ્રક્રિયાઓનો ઉપયોગ કરીને રોઝેનબ્રૉક ફંક્શનનું ન્યૂનતમ મૂલ્ય કેવી રીતે નક્કી કરવું તેના ઉદાહરણો જોઈએ.

નેલ્ડર-મીડ સિમ્પ્લેક્સ પદ્ધતિ

0-પરિમાણીય જગ્યામાં પ્રારંભિક બિંદુ x5 હોવા દો. ચાલો અલ્ગોરિધમનો ઉપયોગ કરીને તેની સૌથી નજીકના રોઝેનબ્રોક ફંક્શનનો ન્યૂનતમ બિંદુ શોધીએ નેલ્ડર-મીડ સિમ્પ્લેક્સ (એલ્ગોરિધમ પદ્ધતિ પરિમાણના મૂલ્ય તરીકે ઉલ્લેખિત છે):

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.]

Broyden-Fletcher-Goldfarb-Shanno (BFGS) અલ્ગોરિધમ

ઉકેલ માટે ઝડપી કન્વર્જન્સ મેળવવા માટે, પ્રક્રિયા BFGS ઉદ્દેશ્ય કાર્યના ઢાળનો ઉપયોગ કરે છે. ગ્રેડિયન્ટને ફંક્શન તરીકે સ્પષ્ટ કરી શકાય છે અથવા ફર્સ્ટ ઓર્ડર ડિફરન્સનો ઉપયોગ કરીને ગણતરી કરી શકાય છે. કોઈ પણ સંજોગોમાં, BFGS પદ્ધતિને સામાન્ય રીતે સિમ્પ્લેક્સ પદ્ધતિ કરતાં ઓછા ફંક્શન કૉલ્સની જરૂર પડે છે.

ચાલો આપણે રોઝેનબ્રોક ફંક્શનનું વ્યુત્પન્ન વિશ્લેષણાત્મક સ્વરૂપમાં શોધીએ:

આ અભિવ્યક્તિ પ્રથમ અને છેલ્લા સિવાયના તમામ ચલોના ડેરિવેટિવ્ઝ માટે માન્ય છે, જે આ રીતે વ્યાખ્યાયિત થયેલ છે:

ચાલો Python ફંક્શન જોઈએ જે આ ઢાળની ગણતરી કરે છે:

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

ગ્રેડિયન્ટ કેલ્ક્યુલેશન ફંક્શનને ન્યૂનતમ ફંક્શનના jac પેરામીટરના મૂલ્ય તરીકે ઉલ્લેખિત કરવામાં આવ્યું છે, નીચે બતાવ્યા પ્રમાણે.

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]

કન્જુગેટ ગ્રેડિયન્ટ અલ્ગોરિધમ (ન્યુટન)

અલ્ગોરિધમ ન્યૂટનના સંયોજક ઢાળ એ ન્યુટનની સંશોધિત પદ્ધતિ છે.
ન્યૂટનની પદ્ધતિ સ્થાનિક વિસ્તારમાં બીજા ડિગ્રીના બહુપદી દ્વારા અંદાજિત કાર્ય પર આધારિત છે:

જ્યાં બીજા ડેરિવેટિવ્ઝનું મેટ્રિક્સ છે (હેસિયન મેટ્રિક્સ, હેસિયન).
જો હેસિયન સકારાત્મક નિશ્ચિત હોય, તો આ કાર્યનું સ્થાનિક લઘુત્તમ ચતુર્ભુજ સ્વરૂપના શૂન્ય ઢાળને શૂન્ય સાથે સરખાવીને શોધી શકાય છે. પરિણામ અભિવ્યક્તિ હશે:

વ્યસ્ત હેસિયનની ગણતરી સંયોજક ઢાળ પદ્ધતિનો ઉપયોગ કરીને કરવામાં આવે છે. રોઝેનબ્રોક કાર્યને ઘટાડવા માટે આ પદ્ધતિનો ઉપયોગ કરવાનું ઉદાહરણ નીચે આપેલ છે. ન્યૂટન-સીજી પદ્ધતિનો ઉપયોગ કરવા માટે, તમારે એક ફંક્શનનો ઉલ્લેખ કરવો આવશ્યક છે જે હેસિયનની ગણતરી કરે છે.
વિશ્લેષણાત્મક સ્વરૂપમાં રોઝેનબ્રૉક ફંક્શનનું હેસિયન સમાન છે:

જ્યાં и , મેટ્રિક્સ વ્યાખ્યાયિત કરો .

મેટ્રિક્સના બાકીના બિન-શૂન્ય તત્વો સમાન છે:

ઉદાહરણ તરીકે, પાંચ-પરિમાણીય જગ્યા N = 5 માં, રોઝનબ્રૉક ફંક્શન માટે હેસિયન મેટ્રિક્સ બેન્ડનું સ્વરૂપ ધરાવે છે:

સંયોજક ઢાળ (ન્યુટન) પદ્ધતિનો ઉપયોગ કરીને રોઝેનબ્રોક ફંક્શનને ઘટાડવા માટે કોડ સાથે આ હેસિયનની ગણતરી કરે છે:

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]

હેસિયન અને મનસ્વી વેક્ટરના ઉત્પાદન કાર્યની વ્યાખ્યા સાથેનું ઉદાહરણ

વાસ્તવિક દુનિયાની સમસ્યાઓમાં, સમગ્ર હેસિયન મેટ્રિક્સની ગણતરી અને સંગ્રહ કરવા માટે નોંધપાત્ર સમય અને મેમરી સંસાધનોની જરૂર પડી શકે છે. આ કિસ્સામાં, વાસ્તવમાં હેસિયન મેટ્રિક્સને સ્પષ્ટ કરવાની જરૂર નથી, કારણ કે મિનિમાઇઝેશન પ્રક્રિયામાં અન્ય મનસ્વી વેક્ટર સાથે હેસિયનના ઉત્પાદનના સમાન વેક્ટરની જરૂર છે. આમ, ગણતરીના દૃષ્ટિકોણથી, ફંક્શનને તરત જ વ્યાખ્યાયિત કરવાનું વધુ પ્રાધાન્યક્ષમ છે જે હેસિયનના ઉત્પાદનનું પરિણામ મનસ્વી વેક્ટર સાથે આપે છે.

હેસ ફંક્શનને ધ્યાનમાં લો, જે મિનિમાઈઝેશન વેક્ટરને પ્રથમ દલીલ તરીકે લે છે અને બીજી દલીલ તરીકે એક આર્બિટરી વેક્ટર લે છે (ઘટાડો કરવાના ફંક્શનની અન્ય દલીલો સાથે). અમારા કિસ્સામાં, મનસ્વી વેક્ટર સાથે રોઝનબ્રોક ફંક્શનના હેસિયનના ઉત્પાદનની ગણતરી કરવી ખૂબ મુશ્કેલ નથી. જો p એક મનસ્વી વેક્ટર છે, પછી ઉત્પાદન ફોર્મ ધરાવે છે:

ફંક્શન કે જે હેસિયન અને આર્બિટરી વેક્ટરના ઉત્પાદનની ગણતરી કરે છે તે હેસસ્પ દલીલના મૂલ્ય તરીકે લઘુત્તમ કાર્ય માટે પસાર થાય છે:

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.])

અમે કદાચ ત્યાં રોકાઈશું. હવે પછીના લેખમાં હું શરતી લઘુત્તમીકરણ વિશેની સૌથી રસપ્રદ બાબતો કહેવાનો પ્રયત્ન કરીશ, અંદાજિત સમસ્યાઓ ઉકેલવામાં લઘુત્તમીકરણનો ઉપયોગ, એક ચલનું કાર્ય ઓછું કરવું, મનસ્વી મિનિમાઇઝર્સ, અને scipy.optimize નો ઉપયોગ કરીને સમીકરણોની સિસ્ટમના મૂળ શોધવા. પેકેજ

સોર્સ: https://docs.scipy.org/doc/scipy/reference/

સોર્સ: www.habr.com