SciPy (సాయి పై అని ఉచ్ఛరిస్తారు) అనేది నంపీ పైథాన్ పొడిగింపు ఆధారంగా ఒక గణిత అప్లికేషన్ ప్యాకేజీ. SciPyతో, మీ ఇంటరాక్టివ్ పైథాన్ సెషన్ MATLAB, IDL, Octave, R-Lab మరియు SciLab వంటి పూర్తి డేటా సైన్స్ మరియు కాంప్లెక్స్ సిస్టమ్ ప్రోటోటైపింగ్ ఎన్విరాన్‌మెంట్‌గా మారుతుంది. ఈరోజు నేను scipy.optimize ప్యాకేజీలో కొన్ని ప్రసిద్ధ ఆప్టిమైజేషన్ అల్గారిథమ్‌లను ఎలా ఉపయోగించాలో గురించి క్లుప్తంగా మాట్లాడాలనుకుంటున్నాను. ఫంక్షన్‌లను ఉపయోగించడంపై మరింత వివరమైన మరియు తాజా సహాయం ఎల్లప్పుడూ help() ఆదేశాన్ని ఉపయోగించి లేదా Shift+Tabని ఉపయోగించి పొందవచ్చు.
పరిచయం
ప్రాథమిక మూలాలను శోధించడం మరియు చదవడం నుండి మిమ్మల్ని మరియు పాఠకులను రక్షించుకోవడానికి, పద్ధతుల వివరణలకు లింక్‌లు ప్రధానంగా వికీపీడియాలో ఉంటాయి. నియమం ప్రకారం, ఈ సమాచారం సాధారణ నిబంధనలలో పద్ధతులను మరియు వారి దరఖాస్తు కోసం షరతులను అర్థం చేసుకోవడానికి సరిపోతుంది. గణిత పద్ధతుల యొక్క సారాంశాన్ని అర్థం చేసుకోవడానికి, ప్రతి కథనం చివరిలో లేదా మీకు ఇష్టమైన శోధన ఇంజిన్‌లో కనుగొనగలిగే మరింత అధికారిక ప్రచురణలకు లింక్‌లను అనుసరించండి.
కాబట్టి, scipy.optimize మాడ్యూల్ కింది విధానాల అమలును కలిగి ఉంటుంది:
- వివిధ అల్గారిథమ్‌లను ఉపయోగించి (నెల్డర్-మీడ్ సింప్లెక్స్, BFGS, న్యూటన్ కంజుగేట్ గ్రేడియంట్స్, и )
- గ్లోబల్ ఆప్టిమైజేషన్ (ఉదాహరణకు: , )
- అవశేషాలను తగ్గించడం (least_squares) మరియు నాన్ లీనియర్ మినిస్ట్ స్క్వేర్‌లను ఉపయోగించి కర్వ్ ఫిట్టింగ్ అల్గారిథమ్‌లు (curve_fit)
- ఒక వేరియబుల్ (minim_scalar) యొక్క స్కేలార్ ఫంక్షన్‌లను కనిష్టీకరించడం మరియు మూలాల కోసం శోధించడం (root_scalar)
- వివిధ అల్గారిథమ్‌లను ఉపయోగించి సమీకరణాల వ్యవస్థ (రూట్) యొక్క బహుమితీయ పరిష్కర్తలు (హైబ్రిడ్ పావెల్, లేదా వంటి పెద్ద ఎత్తున పద్ధతులు ).
ఈ వ్యాసంలో మేము ఈ మొత్తం జాబితా నుండి మొదటి అంశాన్ని మాత్రమే పరిశీలిస్తాము.
అనేక వేరియబుల్స్ యొక్క స్కేలార్ ఫంక్షన్ యొక్క షరతులు లేని కనిష్టీకరణ
scipy.optimize ప్యాకేజీ నుండి కనిష్ట ఫంక్షన్ అనేక వేరియబుల్స్ యొక్క స్కేలార్ ఫంక్షన్ల యొక్క షరతులతో కూడిన మరియు షరతులు లేని కనిష్టీకరణ సమస్యలను పరిష్కరించడానికి సాధారణ ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ఇది ఎలా పని చేస్తుందో ప్రదర్శించడానికి, మనకు అనేక వేరియబుల్స్ యొక్క తగిన ఫంక్షన్ అవసరం, దానిని మేము వివిధ మార్గాల్లో కనిష్టీకరించాము.
ఈ ప్రయోజనాల కోసం, N వేరియబుల్స్ యొక్క Rosenbrock ఫంక్షన్ ఖచ్చితమైనది, ఇది రూపం కలిగి ఉంటుంది:
Rosenbrock ఫంక్షన్ మరియు దాని Jacobi మరియు Hessian మాత్రికలు (వరుసగా మొదటి మరియు రెండవ ఉత్పన్నాలు) 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 విధానాలను ఉపయోగించి Rosenbrock ఫంక్షన్ యొక్క కనీస విలువను ఎలా నిర్ణయించాలో ఉదాహరణలను చూద్దాం.
నెల్డర్-మీడ్ సింప్లెక్స్ పద్ధతి
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.]బ్రాయిడెన్-ఫ్లెచర్-గోల్డ్‌ఫార్బ్-షాన్నో (BFGS) అల్గోరిథం
ఒక పరిష్కారానికి వేగవంతమైన కలయికను పొందేందుకు, ప్రక్రియ ఆబ్జెక్టివ్ ఫంక్షన్ యొక్క ప్రవణతను ఉపయోగిస్తుంది. గ్రేడియంట్‌ను ఫంక్షన్‌గా పేర్కొనవచ్చు లేదా మొదటి ఆర్డర్ తేడాలను ఉపయోగించి లెక్కించవచ్చు. ఏదైనా సందర్భంలో, BFGS పద్ధతికి సాధారణంగా సింప్లెక్స్ పద్ధతి కంటే తక్కువ ఫంక్షన్ కాల్‌లు అవసరం.
విశ్లేషణాత్మక రూపంలో Rosenbrock ఫంక్షన్ యొక్క ఉత్పన్నాన్ని కనుగొనండి:
ఈ వ్యక్తీకరణ మొదటి మరియు చివరి మినహా అన్ని వేరియబుల్స్ యొక్క ఉత్పన్నాలకు చెల్లుతుంది, అవి ఇలా నిర్వచించబడ్డాయి:
ఈ ప్రవణతను లెక్కించే పైథాన్ ఫంక్షన్‌ను చూద్దాం:
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.]క్రిలోవ్ రకం పద్ధతులు
Trust-ncg పద్ధతి వలె, క్రిలోవ్-రకం పద్ధతులు పెద్ద-స్థాయి సమస్యలను పరిష్కరించడానికి బాగా సరిపోతాయి ఎందుకంటే అవి మ్యాట్రిక్స్-వెక్టార్ ఉత్పత్తులను మాత్రమే ఉపయోగిస్తాయి. వారి సారాంశం కత్తిరించబడిన క్రిలోవ్ సబ్‌స్పేస్ ద్వారా పరిమితం చేయబడిన విశ్వాస ప్రాంతంలో సమస్యను పరిష్కరించడం. అనిశ్చిత సమస్యల కోసం, ఈ పద్ధతిని ఉపయోగించడం ఉత్తమం, ఎందుకంటే ఇది Trust-ncg పద్ధతితో పోల్చితే, ఒక్కో సబ్‌ప్రాబ్లమ్‌కు తక్కువ సంఖ్యలో మ్యాట్రిక్స్-వెక్టార్ ఉత్పత్తుల కారణంగా నాన్‌లీనియర్ పునరావృతాలను తక్కువ సంఖ్యలో ఉపయోగిస్తుంది. అదనంగా, ట్రస్ట్-ఎన్‌సిజి పద్ధతిని ఉపయోగించడం కంటే క్వాడ్రాటిక్ సబ్‌ప్రాబ్లెమ్‌కు పరిష్కారం మరింత ఖచ్చితంగా కనుగొనబడుతుంది.
హెస్సియన్ మాతృక యొక్క నిర్వచనంతో ఉదాహరణ:
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.xOptimization 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 ఉపయోగించి సమీకరణాల వ్యవస్థ యొక్క మూలాలను కనుగొనడం గురించి చాలా ఆసక్తికరమైన విషయాలను చెప్పడానికి ప్రయత్నిస్తాను. ప్యాకేజీ.
మూలం:
మూలం: www.habr.com