SciPy (సాయి పై అని ఉచ్ఛరిస్తారు) అనేది నంపీ-ఆధారిత గణిత శాస్త్ర ప్యాకేజీ, ఇందులో C మరియు ఫోర్ట్రాన్ లైబ్రరీలు కూడా ఉన్నాయి. SciPy మీ ఇంటరాక్టివ్ పైథాన్ సెషన్‌ను MATLAB, IDL, Octave, R లేదా SciLab వంటి పూర్తి డేటా సైన్స్ వాతావరణంగా మారుస్తుంది.
ఈ ఆర్టికల్‌లో, మేము గణిత ప్రోగ్రామింగ్ యొక్క ప్రాథమిక పద్ధతులను పరిశీలిస్తాము - scipy.optimize ప్యాకేజీని ఉపయోగించి అనేక వేరియబుల్స్ యొక్క స్కేలార్ ఫంక్షన్ కోసం షరతులతో కూడిన ఆప్టిమైజేషన్ సమస్యలను పరిష్కరించడం. నియంత్రణ లేని ఆప్టిమైజేషన్ అల్గారిథమ్‌లు ఇప్పటికే చర్చించబడ్డాయి . హెల్ప్() కమాండ్, Shift+Tab లేదా in ఉపయోగించి scipy ఫంక్షన్‌లపై మరింత వివరణాత్మక మరియు తాజా సహాయాన్ని ఎల్లప్పుడూ పొందవచ్చు .
పరిచయం
scipy.optimize ప్యాకేజీలో షరతులతో కూడిన మరియు నియంత్రణ లేని ఆప్టిమైజేషన్ సమస్యలను పరిష్కరించడానికి ఒక సాధారణ ఇంటర్‌ఫేస్ ఫంక్షన్ ద్వారా అందించబడుతుంది. minimize(). ఏదేమైనా, అన్ని సమస్యలను పరిష్కరించడానికి సార్వత్రిక పద్ధతి లేదని తెలిసింది, కాబట్టి తగిన పద్ధతి యొక్క ఎంపిక, ఎప్పటిలాగే, పరిశోధకుడి భుజాలపై వస్తుంది.
ఫంక్షన్ ఆర్గ్యుమెంట్ ఉపయోగించి తగిన ఆప్టిమైజేషన్ అల్గోరిథం పేర్కొనబడింది minimize(..., method="").
అనేక వేరియబుల్స్ ఫంక్షన్ యొక్క షరతులతో కూడిన ఆప్టిమైజేషన్ కోసం, క్రింది పద్ధతుల అమలు అందుబాటులో ఉన్నాయి:
trust-constr- విశ్వసనీయ ప్రాంతంలో స్థానిక కనిష్టాన్ని శోధించండి. , ;SLSQP— పరిమితులతో కూడిన సీక్వెన్షియల్ క్వాడ్రాటిక్ ప్రోగ్రామింగ్, లాగ్రాంజ్ సిస్టమ్‌ను పరిష్కరించడానికి న్యూటోనియన్ పద్ధతి. .TNC- కత్తిరించబడిన న్యూటన్ నిర్బంధిత, పరిమిత సంఖ్యలో పునరావృత్తులు, పెద్ద సంఖ్యలో స్వతంత్ర వేరియబుల్స్‌తో నాన్‌లీనియర్ ఫంక్షన్‌లకు మంచిది. .L-BFGS-B- బ్రాయిడెన్-ఫ్లెచర్-గోల్డ్‌ఫార్బ్-షాన్నో బృందం నుండి ఒక పద్ధతి, హెస్సియన్ మ్యాట్రిక్స్ నుండి వెక్టర్‌లను పాక్షికంగా లోడ్ చేయడం వల్ల తగ్గిన మెమరీ వినియోగంతో అమలు చేయబడింది. , .COBYLA— MARE లీనియర్ ఉజ్జాయింపు ద్వారా నిర్బంధ ఆప్టిమైజేషన్, లీనియర్ ఉజ్జాయింపుతో నిర్బంధ ఆప్టిమైజేషన్ (గ్రేడియంట్ లెక్కింపు లేకుండా). .
ఎంచుకున్న పద్ధతిని బట్టి, సమస్యను పరిష్కరించడానికి షరతులు మరియు పరిమితులు భిన్నంగా సెట్ చేయబడతాయి:
- తరగతి వస్తువు
Boundsపద్ధతుల కోసం L-BFGS-B, TNC, SLSQP, Trust-constr; - జాబితా
(min, max)అదే పద్ధతుల కోసం L-BFGS-B, TNC, SLSQP, Trust-constr; - ఒక వస్తువు లేదా వస్తువుల జాబితా
LinearConstraint,NonlinearConstraintCOBYLA, SLSQP, Trust-constr మెథడ్స్ కోసం; - నిఘంటువు లేదా నిఘంటువుల జాబితా
{'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt}COBYLA, SLSQP పద్ధతుల కోసం.
వ్యాసం రూపురేఖలు:
1) ట్రస్ట్ రీజియన్‌లో షరతులతో కూడిన ఆప్టిమైజేషన్ అల్గోరిథం యొక్క ఉపయోగాన్ని పరిగణించండి (పద్ధతి=”ట్రస్ట్-కాన్స్ట్ర్”) వస్తువులుగా పేర్కొన్న పరిమితులతో Bounds, LinearConstraint, NonlinearConstraint ;
2) డిక్షనరీ రూపంలో పేర్కొన్న పరిమితులతో అతి తక్కువ చతురస్రాల పద్ధతిని (పద్ధతి = "SLSQP") ఉపయోగించి సీక్వెన్షియల్ ప్రోగ్రామింగ్‌ను పరిగణించండి {'type', 'fun', 'jac', 'args'};
3) వెబ్ స్టూడియో ఉదాహరణను ఉపయోగించి తయారు చేయబడిన ఉత్పత్తుల యొక్క ఆప్టిమైజేషన్ యొక్క ఉదాహరణను విశ్లేషించండి.
షరతులతో కూడిన ఆప్టిమైజేషన్ పద్ధతి="ట్రస్ట్-కాన్స్ట్ర్"
పద్ధతి యొక్క అమలు trust-constr ఆధారంగా సమానత్వం మరియు ఆన్ రూపం యొక్క పరిమితులతో సమస్యల కోసం అసమానతల రూపంలో పరిమితులతో సమస్యల కోసం. విశ్వసనీయ ప్రాంతంలో స్థానిక కనిష్టాన్ని కనుగొనడానికి రెండు పద్ధతులు అల్గారిథమ్‌ల ద్వారా అమలు చేయబడతాయి మరియు పెద్ద-స్థాయి సమస్యలకు బాగా సరిపోతాయి.
సాధారణ రూపంలో కనిష్టాన్ని కనుగొనే సమస్య యొక్క గణిత సూత్రీకరణ:
కఠినమైన సమానత్వ పరిమితుల కోసం, దిగువ సరిహద్దు ఎగువ సరిహద్దుకు సమానంగా సెట్ చేయబడింది .
వన్-వే పరిమితి కోసం, ఎగువ లేదా దిగువ పరిమితి సెట్ చేయబడింది np.inf సంబంధిత గుర్తుతో.
రెండు వేరియబుల్స్ యొక్క తెలిసిన రోసెన్‌బ్రాక్ ఫంక్షన్ యొక్క కనిష్టాన్ని కనుగొనడం అవసరం:
ఈ సందర్భంలో, దాని నిర్వచనం యొక్క డొమైన్‌పై క్రింది పరిమితులు సెట్ చేయబడ్డాయి:
మా విషయంలో, పాయింట్ వద్ద ఒక ఏకైక పరిష్కారం ఉంది , దీని కోసం మొదటి మరియు నాల్గవ పరిమితులు మాత్రమే చెల్లుతాయి.
దిగువ నుండి పై వరకు పరిమితుల ద్వారా వెళ్లి వాటిని స్కిపీలో ఎలా వ్రాయవచ్చో చూద్దాం.
ఆంక్షలు и దానిని బౌండ్స్ ఆబ్జెక్ట్ ఉపయోగించి నిర్వచిద్దాం.
from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])ఆంక్షలు и దానిని సరళ రూపంలో వ్రాస్దాం:
ఈ పరిమితులను లీనియర్ కాన్‌స్ట్రైంట్ ఆబ్జెక్ట్‌గా నిర్వచిద్దాం:
import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])చివరకు మాతృక రూపంలో నాన్ లీనియర్ పరిమితి:
మేము ఈ పరిమితి కోసం జాకోబియన్ మాతృకను నిర్వచించాము మరియు హెస్సియన్ మాతృక యొక్క ఏకపక్ష వెక్టర్‌తో సరళ కలయిక :
ఇప్పుడు మనం నాన్ లీనియర్ పరిమితిని ఒక వస్తువుగా నిర్వచించవచ్చు NonlinearConstraint:
from scipy.optimize import NonlinearConstraint
def cons_f(x):
return [x[0]**2 + x[1], x[0]**2 - x[1]]
def cons_J(x):
return [[2*x[0], 1], [2*x[0], -1]]
def cons_H(x, v):
return v[0]*np.array([[2, 0], [0, 0]]) + v[1]*np.array([[2, 0], [0, 0]])
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=cons_H)పరిమాణం పెద్దది అయినట్లయితే, మాత్రికలను కూడా చిన్న రూపంలో పేర్కొనవచ్చు:
from scipy.sparse import csc_matrix
def cons_H_sparse(x, v):
return v[0]*csc_matrix([[2, 0], [0, 0]]) + v[1]*csc_matrix([[2, 0], [0, 0]])
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1,
jac=cons_J, hess=cons_H_sparse)లేదా ఒక వస్తువుగా LinearOperator:
from scipy.sparse.linalg import LinearOperator
def cons_H_linear_operator(x, v):
def matvec(p):
return np.array([p[0]*2*(v[0]+v[1]), 0])
return LinearOperator((2, 2), matvec=matvec)
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1,
jac=cons_J, hess=cons_H_linear_operator)హెస్సియన్ మాతృకను లెక్కించేటప్పుడు చాలా ప్రయత్నం అవసరం, మీరు తరగతిని ఉపయోగించవచ్చు . కింది వ్యూహాలు అందుబాటులో ఉన్నాయి: BFGS и SR1.
from scipy.optimize import BFGS
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())పరిమిత తేడాలను ఉపయోగించి హెస్సియన్‌ను కూడా లెక్కించవచ్చు:
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')పరిమిత భేదాలను ఉపయోగించి పరిమితుల కోసం జాకోబియన్ మాతృకను కూడా లెక్కించవచ్చు. అయితే, ఈ సందర్భంలో హెస్సియన్ మాతృకను పరిమిత వ్యత్యాసాలను ఉపయోగించి లెక్కించలేము. Hessian తప్పనిసరిగా ఒక ఫంక్షన్‌గా నిర్వచించబడాలి లేదా HessianUpdateStrategy తరగతిని ఉపయోగించాలి.
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = '2-point', hess = BFGS ())ఆప్టిమైజేషన్ సమస్యకు పరిష్కారం ఇలా కనిపిస్తుంది:
from scipy.optimize import minimize
from scipy.optimize import rosen, rosen_der, rosen_hess, rosen_hess_prod
x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess,
constraints=[linear_constraint, nonlinear_constraint],
options={'verbose': 1}, bounds=bounds)
print(res.x)`gtol` termination condition is satisfied.
Number of iterations: 12, function evaluations: 8, CG iterations: 7, optimality: 2.99e-09, constraint violation: 1.11e-16, execution time: 0.033 s.
[0.41494531 0.17010937]అవసరమైతే, లీనియర్ ఆపరేటర్ క్లాస్‌ని ఉపయోగించి హెస్సియన్‌ను లెక్కించే విధిని నిర్వచించవచ్చు
def rosen_hess_linop(x):
def matvec(p):
return rosen_hess_prod(x, p)
return LinearOperator((2, 2), matvec=matvec)
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess_linop,
constraints=[linear_constraint, nonlinear_constraint],
options={'verbose': 1}, bounds=bounds)
print(res.x)లేదా పరామితి ద్వారా హెస్సియన్ మరియు ఏకపక్ష వెక్టర్ యొక్క ఉత్పత్తి hessp:
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hessp=rosen_hess_prod,
constraints=[linear_constraint, nonlinear_constraint],
options={'verbose': 1}, bounds=bounds)
print(res.x)ప్రత్యామ్నాయంగా, ఆప్టిమైజ్ చేయబడిన ఫంక్షన్ యొక్క మొదటి మరియు రెండవ ఉత్పన్నాలను అంచనా వేయవచ్చు. ఉదాహరణకు, ఫంక్షన్‌ని ఉపయోగించి హెస్సియన్‌ని అంచనా వేయవచ్చు SR1 (క్వాసి-న్యూటోనియన్ ఉజ్జాయింపు). పరిమిత వ్యత్యాసాల ద్వారా ప్రవణతను అంచనా వేయవచ్చు.
from scipy.optimize import SR1
res = minimize(rosen, x0, method='trust-constr', jac="2-point", hess=SR1(),
constraints=[linear_constraint, nonlinear_constraint],
options={'verbose': 1}, bounds=bounds)
print(res.x)షరతులతో కూడిన ఆప్టిమైజేషన్ పద్ధతి="SLSQP"
SLSQP పద్ధతి ఫారమ్‌లో ఫంక్షన్‌ను తగ్గించడంలో సమస్యలను పరిష్కరించడానికి రూపొందించబడింది:
పేరు и - సమానత్వం లేదా అసమానతల రూపంలో పరిమితులను వివరించే వ్యక్తీకరణల సూచికల సెట్లు. - ఫంక్షన్ యొక్క నిర్వచనం యొక్క డొమైన్ కోసం దిగువ మరియు ఎగువ సరిహద్దుల సెట్లు.
లీనియర్ మరియు నాన్ లీనియర్ పరిమితులు కీలతో నిఘంటువుల రూపంలో వివరించబడ్డాయి type, fun и jac.
ineq_cons = {'type': 'ineq',
'fun': lambda x: np.array ([1 - x [0] - 2 * x [1],
1 - x [0] ** 2 - x [1],
1 - x [0] ** 2 + x [1]]),
'jac': lambda x: np.array ([[- 1.0, -2.0],
[-2 * x [0], -1.0],
[-2 * x [0], 1.0]])
}
eq_cons = {'type': 'eq',
'fun': lambda x: np.array ([2 * x [0] + x [1] - 1]),
'jac': lambda x: np.array ([2.0, 1.0])
}కనిష్ట శోధన క్రింది విధంగా నిర్వహించబడుతుంది:
x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='SLSQP', jac=rosen_der,
constraints=[eq_cons, ineq_cons], options={'ftol': 1e-9, 'disp': True},
bounds=bounds)
print(res.x)Optimization terminated successfully. (Exit mode 0)
Current function value: 0.34271757499419825
Iterations: 4
Function evaluations: 5
Gradient evaluations: 4
[0.41494475 0.1701105 ]ఆప్టిమైజేషన్ ఉదాహరణ
ఐదవ సాంకేతిక నిర్మాణానికి పరివర్తనకు సంబంధించి, వెబ్ స్టూడియో యొక్క ఉదాహరణను ఉపయోగించి ఉత్పత్తి ఆప్టిమైజేషన్‌ను చూద్దాం, ఇది మాకు చిన్నది కాని స్థిరమైన ఆదాయాన్ని తెస్తుంది. మూడు రకాల ఉత్పత్తులను ఉత్పత్తి చేసే గాలీ డైరెక్టర్‌గా మనల్ని మనం ఊహించుకుందాం:
- x0 - ల్యాండింగ్ పేజీలను విక్రయిస్తోంది, 10 tr నుండి.
- x1 - కార్పొరేట్ వెబ్‌సైట్‌లు, 20 tr నుండి.
- x2 - ఆన్‌లైన్ స్టోర్‌లు, 30 tr నుండి.
మా స్నేహపూర్వక వర్కింగ్ టీమ్‌లో నలుగురు జూనియర్లు, ఇద్దరు మిడిల్స్ మరియు ఒక సీనియర్ ఉన్నారు. వారి నెలవారీ పని సమయ నిధి:
- జూన్‌లు:
4 * 150 = 600 чел * час, - మధ్యస్థాలు:
2 * 150 = 300 чел * час, - సీనియర్:
150 чел * час.
అందుబాటులో ఉన్న మొదటి జూనియర్ (0, 1, 2) గంటలను ఒక రకమైన (x10, x20, x30), మిడిల్ - (7, 15, 20), సీనియర్ - (5, 10, 15) అభివృద్ధి మరియు విస్తరణ కోసం వెచ్చించనివ్వండి ) మీ జీవితంలోని ఉత్తమ సమయం యొక్క గంటలు.
ఏ సాధారణ దర్శకుడిలాగే, మేము నెలవారీ లాభాలను పెంచుకోవాలనుకుంటున్నాము. ఆబ్జెక్టివ్ ఫంక్షన్‌ను వ్రాయడం విజయానికి మొదటి మెట్టు value నెలకు ఉత్పత్తి చేయబడిన ఉత్పత్తుల నుండి వచ్చే ఆదాయం మొత్తంగా:
def value(x):
return - 10*x[0] - 20*x[1] - 30*x[2]ఇది లోపం కాదు; గరిష్టంగా శోధిస్తున్నప్పుడు, ఆబ్జెక్టివ్ ఫంక్షన్ వ్యతిరేక గుర్తుతో కనిష్టీకరించబడుతుంది.
తదుపరి దశ ఏమిటంటే, మా ఉద్యోగులను అధిక పని చేయకుండా నిషేధించడం మరియు పని గంటలపై పరిమితులను ప్రవేశపెట్టడం:
సమానమైనది ఏమిటి:
ineq_cons = {'type': 'ineq',
'fun': lambda x: np.array ([600 - 10 * x [0] - 20 * x [1] - 30 * x[2],
300 - 7 * x [0] - 15 * x [1] - 20 * x[2],
150 - 5 * x [0] - 10 * x [1] - 15 * x[2]])
}అధికారిక పరిమితి ఏమిటంటే ఉత్పత్తి అవుట్‌పుట్ తప్పనిసరిగా సానుకూలంగా ఉండాలి:
bnds = Bounds ([0, 0, 0], [np.inf, np.inf, np.inf])చివరగా, చాలా రోజీ ఊహ ఏమిటంటే, తక్కువ ధర మరియు అధిక నాణ్యత కారణంగా, సంతృప్తి చెందిన కస్టమర్ల క్యూ నిరంతరం మా కోసం వరుసలో ఉంటుంది. దీనితో నిర్బంధిత ఆప్టిమైజేషన్ సమస్యను పరిష్కరించడం ఆధారంగా, నెలవారీ ఉత్పత్తి వాల్యూమ్‌లను మనమే ఎంచుకోవచ్చు scipy.optimize:
x0 = np.array([10, 10, 10])
res = minimize(value, x0, method='SLSQP', constraints=ineq_cons, bounds=bnds)
print(res.x)[7.85714286 5.71428571 3.57142857]పూర్ణ సంఖ్యలకు వదులుగా రౌండ్ చేయండి మరియు ఉత్పత్తుల యొక్క సరైన పంపిణీతో రోవర్ల నెలవారీ లోడ్‌ను గణిద్దాం x = (8, 6, 3) :
- జూన్‌లు:
8 * 10 + 6 * 20 + 3 * 30 = 290 чел * час; - మధ్యస్థాలు:
8 * 7 + 6 * 15 + 3 * 20 = 206 чел * час; - సీనియర్:
8 * 5 + 6 * 10 + 3 * 15 = 145 чел * час.
తీర్మానం: దర్శకుడు తన అర్హత గల గరిష్టాన్ని పొందాలంటే, నెలకు 8 ల్యాండింగ్ పేజీలు, 6 మధ్య తరహా సైట్‌లు మరియు 3 స్టోర్‌లను సృష్టించడం సరైనది. ఈ సందర్భంలో, సీనియర్ యంత్రం నుండి పైకి చూడకుండా దున్నాలి, మిడిల్స్ యొక్క లోడ్ సుమారుగా 2/3 ఉంటుంది, జూనియర్లు సగం కంటే తక్కువగా ఉంటారు.
తీర్మానం
ప్యాకేజీతో పని చేయడానికి ప్రాథమిక పద్ధతులను వ్యాసం వివరిస్తుంది scipy.optimize, షరతులతో కూడిన కనిష్టీకరణ సమస్యలను పరిష్కరించడానికి ఉపయోగిస్తారు. వ్యక్తిగతంగా నేను ఉపయోగిస్తాను scipy పూర్తిగా అకడమిక్ ప్రయోజనాల కోసం, అందుకే ఇచ్చిన ఉదాహరణ అటువంటి హాస్య స్వభావం కలిగి ఉంటుంది.
చాలా సిద్ధాంతం మరియు వర్చువల్ ఉదాహరణలు కనుగొనవచ్చు, ఉదాహరణకు, I.L. అకులిచ్ పుస్తకంలో "ఉదాహరణలు మరియు సమస్యలలో గణిత ప్రోగ్రామింగ్." మరింత హార్డ్కోర్ అప్లికేషన్ scipy.optimize చిత్రాల సమితి నుండి 3D నిర్మాణాన్ని నిర్మించడానికి () లో చూడవచ్చు .
సమాచారం యొక్క ప్రధాన మూలం దీని మరియు ఇతర విభాగాల అనువాదానికి సహకరించాలనుకునే వారు scipy కు స్వాగతం .
Спасибо ప్రచురణ తయారీలో పాల్గొనడం కోసం.
మూలం: www.habr.com