ʻO SciPy (ʻōlelo ʻia sai pie) he pūʻolo makemakika ma muli o ka numpy e komo pū ana me nā hale waihona puke C a me Fortran. Hoʻololi ʻo SciPy i kāu kau Python interactive i kahi ʻepekema ʻikepili piha e like me MATLAB, IDL, Octave, R, a i ʻole SciLab.
Ma kēia ʻatikala, e nānā mākou i nā ʻenehana kumu o ka hoʻolālā makemakika - ka hoʻonā ʻana i nā pilikia optimization conditional no kahi hana scalar o kekahi mau mea hoʻololi me ka hoʻohana ʻana i ka pūʻolo scipy.optimize. Ua kūkākūkā mua ʻia nā algorithms optimization unconstrained . Hiki ke loaʻa ke kōkua kikoʻī hou aʻe i nā hana scipy me ke kauoha kōkua (), Shift+Tab a i ʻole .
Hōʻike
Hāʻawi ʻia kahi pānaʻi maʻamau no ka hoʻoponopono ʻana i nā pilikia optimization conditional a unconstrained i loko o ka pūʻolo scipy.optimize e ka hana. minimize(). Eia naʻe, ua ʻike ʻia ʻaʻohe ala ākea no ka hoʻoponopono ʻana i nā pilikia āpau, no laila ke koho ʻana i kahi ala kūpono, e like me nā manawa a pau, e hāʻule i nā poʻohiwi o ka mea noiʻi.
Hōʻike ʻia ka algorithm optimization kūpono me ka hoʻohana ʻana i ka manaʻo hana minimize(..., method="").
No ka loiloi kūlana o kahi hana o nā ʻano like ʻole, loaʻa nā hoʻokō o kēia mau ʻano:
trust-constr— ʻimi no ka palena iki ma ka ʻāina hilinaʻi. , ;SLSQP— ka papahana quadratic sequential me nā kaohi, ke ala Newtonian no ka hoʻonā ʻana i ka ʻōnaehana Lagrange. .TNC- Hoʻopaʻa ʻia ʻo Newton i hoʻopaʻa ʻia, helu palena ʻia o nā iterations, maikaʻi no nā hana nonlinear me ka nui o nā mea hoʻololi kūʻokoʻa. .L-BFGS-B- he ala mai ka hui Broyden-Fletcher-Goldfarb-Shanno, i hoʻokō ʻia me ka hoʻemi ʻana i ka hoʻomanaʻo ʻana ma muli o ka hoʻouka ʻana o nā vectors mai ka Hessian matrix. , .COBYLA— Hoʻopono ʻia ʻo MARE Ma ka Linear Approximation, hoʻokaʻawale ʻia me ka hoʻohālikelike laina (me ka ʻole o ka helu gradient). .
Ma muli o ke ʻano i koho ʻia, hoʻonohonoho ʻokoʻa nā kūlana a me nā palena no ka hoʻoponopono ʻana i ka pilikia:
- mea papa
Boundsno nā ʻano L-BFGS-B, TNC, SLSQP, trust-constr; - ka papa inoa
(min, max)no nā ʻano like L-BFGS-B, TNC, SLSQP, trust-constr; - he mea a papa inoa paha
LinearConstraint,NonlinearConstraintno COBYLA, SLSQP, nā ʻano hilinaʻi-constr; - puke wehewehe ʻōlelo a papa inoa paha
{'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt}no nā ʻano COBYLA, SLSQP.
ʻatikala:
1) E noʻonoʻo i ka hoʻohana ʻana i kahi algorithm optimization conditional ma ka ʻāina hilinaʻi (method=”trust-constr”) me nā kaohi i kuhikuhi ʻia he mau mea. Bounds, LinearConstraint, NonlinearConstraint ;
2) E noʻonoʻo i ka hoʻonohonoho ʻana i ka hoʻonohonoho ʻana i nā ʻāpana liʻiliʻi liʻiliʻi loa (method=”SLSQP”) me nā kaohi i kuhikuhi ʻia ma ke ʻano he puke wehewehe. {'type', 'fun', 'jac', 'args'};
3) E noʻonoʻo i kahi laʻana o ka hoʻonui ʻana i nā huahana i hana ʻia me ka hoʻohana ʻana i ka laʻana o kahi studio pūnaewele.
Kūlana hoʻolālā ʻano = "trust-constr"
Ka hoʻokō ʻana i ke ʻano trust-constr ma muli o no nā pilikia me nā kaohi o ke ʻano like a ma luna no nā pilikia me nā kaohi ma ke ʻano o nā like ʻole. Hoʻokō ʻia nā ʻano ʻelua e nā algorithms no ka loaʻa ʻana o kahi palena liʻiliʻi ma ka ʻāina hilinaʻi a kūpono hoʻi no nā pilikia nui.
ʻO ka hoʻokumu ʻana i ka makemakika o ka pilikia o ka loaʻa ʻana o ka liʻiliʻi ma ke ʻano maʻamau:
No nā kaohi kaulike koʻikoʻi, ua hoʻonohonoho ʻia ka palena haʻahaʻa e like me ka palena o luna .
No ke kaohi ʻana hoʻokahi ala, hoʻonoho ʻia ka palena luna a i ʻole ka palena haʻahaʻa np.inf me ka hoailona pili.
Pono e ʻimi i ka liʻiliʻi o kahi hana Rosenbrock i ʻike ʻia o ʻelua mau ʻano hoʻololi:
I kēia hihia, ua hoʻonoho ʻia nā palena ma lalo o kāna ʻāpana wehewehe:
I kā mākou hihia, aia kahi hoʻonā kū hoʻokahi ma ke kiko , no ka mea, ʻo nā kapu mua a me ka ʻehā wale nō i kūpono.
E hele kāua i nā kapu mai lalo a luna a nānā pehea e hiki ai iā mākou ke kākau iā lākou ma ka scipy.
Nā palena и e wehewehe kākou me ka hoʻohana ʻana i ka mea Bounds.
from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])Nā palena и E kākau kākou ma ke ʻano laina:
E wehewehe kākou i kēia mau kaohi ma ke ʻano he mea LinearConstraint:
import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])A ʻo ka mea hope loa ka palena palena ʻole ma ke ʻano matrix:
Wehewehe mākou i ka matrix Jacobian no kēia kaohi a me ka hui pū ʻana o ka matrix Hessian me kahi vector arbitrary. :
I kēia manawa hiki iā mākou ke wehewehe i kahi palena ʻole ma ke ʻano he mea 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)Inā nui ka nui, hiki ke kuhikuhi ʻia nā matrices ma ke ʻano liʻiliʻi:
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)a i ʻole ma ke ʻano he mea 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)I ka helu ʻana i ka matrix Hessian makemake nui i ka hana, hiki iā ʻoe ke hoʻohana i kahi papa . Loaʻa kēia mau hoʻolālā: BFGS и SR1.
from scipy.optimize import BFGS
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())Hiki ke helu ʻia ka Hessian me ka hoʻohana ʻana i nā ʻokoʻa palena:
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')Hiki ke helu ʻia ka matrix Jacobian no nā kaohi me ka hoʻohana ʻana i nā ʻokoʻa palena. Eia naʻe, ma kēia hihia ʻaʻole hiki ke helu ʻia ka matrix Hessian me ka hoʻohana ʻana i nā ʻokoʻa palena. Pono e wehewehe ʻia ka Hessian ma ke ʻano he hana a hoʻohana paha i ka papa HessianUpdateStrategy.
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = '2-point', hess = BFGS ())ʻO ka hoʻonā i ka pilikia optimization e like me kēia:
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]Inā pono, hiki ke wehewehe ʻia ka hana no ka helu ʻana i ka Hessian me ka hoʻohana ʻana i ka papa LinearOperator
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)a i ʻole ka huahana o ka Hessian a me kahi vector kuʻuna ma o ka ʻāpana 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)ʻO kahi ʻē aʻe, hiki ke hoʻopili ʻia nā derivatives mua a me ka lua o ka hana i hoʻopaʻa ʻia. No ka laʻana, hiki ke hoʻohālikelike ʻia ka Hessian me ka hoʻohana ʻana i ka hana SR1 (kokoke like-Newtonian). Hiki ke hoʻopili ʻia ka gradient e nā ʻokoʻa palena.
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)ʻO ke ʻano loiloi kūlana = "SLSQP"
Hoʻolālā ʻia ke ʻano SLSQP e hoʻoponopono i nā pilikia o ka hōʻemi ʻana i kahi hana ma ke ʻano:
'Ahea и - nā pūʻulu o nā huaʻōlelo e wehewehe ana i nā kapu ma ke ʻano o nā kaulike a i ʻole nā mea like ʻole. — nā hoʻonohonoho o nā palena haʻahaʻa a me luna no ke kikowaena o ka wehewehe ʻana o ka hana.
Hōʻike ʻia nā palena laina a me ka laina ʻole ma ke ʻano o nā puke wehewehe ʻōlelo me nā kī 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])
}ʻO ka ʻimi ʻana i ka mea liʻiliʻi e hana ʻia penei:
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 ]Laʻana Hoʻonui
E pili ana i ka hoʻololi ʻana i ka ʻenehana ʻenehana ʻelima, e nānā kākou i ka hoʻonui ʻana i ka hana me ka hoʻohana ʻana i ka laʻana o kahi studio pūnaewele, e lawe mai iā mākou i kahi kālā liʻiliʻi akā paʻa. E noʻonoʻo kākou iā mākou iho he alakaʻi o ke kaʻa kaʻa e hana ana i ʻekolu ʻano huahana:
- x0 - kūʻai aku i nā ʻaoʻao pae, mai 10 tr.
- x1 - nā pūnaewele hui, mai 20 tr.
- x2 - nā hale kūʻai pūnaewele, mai 30 tr.
ʻO kā mākou hui hana aloha he ʻehā juniors, ʻelua waena a me hoʻokahi poʻokela. ʻO kā lākou kālā manawa hana o kēlā me kēia mahina:
- Iune:
4 * 150 = 600 чел * час, - waena:
2 * 150 = 300 чел * час, - senor:
150 чел * час.
E hoʻolimalima ka poʻe ʻōpio mua loa (0, 1, 2) mau hola ma ka hoʻomohala ʻana a me ka hoʻolaha ʻana o kahi pūnaewele o ke ʻano (x10, x20, x30), waena - (7, 15, 20), luna - (5, 10, 15 ) hola o ka manawa maikaʻi loa o kou ola.
E like me ke alakaʻi maʻamau, makemake mākou e hoʻonui i ka loaʻa kālā o kēlā me kēia mahina. ʻO ka hana mua i ka holomua ʻo ke kākau ʻana i ka hana pahuhopu value e like me ka nui o ka loaʻa kālā mai nā huahana i hana ʻia i kēlā me kēia mahina:
def value(x):
return - 10*x[0] - 20*x[1] - 30*x[2]ʻAʻole kēia he hewa; i ka ʻimi ʻana i ka mea kiʻekiʻe, hoʻemi ʻia ka hana pahuhopu me ka hōʻailona ʻē aʻe.
ʻO ka hana aʻe, ʻo ia ka pāpā ʻana i kā mākou poʻe limahana mai ka hana nui a hoʻokomo i nā mea paʻa i nā hola hana:
He aha ka mea like:
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]])
}ʻO ka palena maʻamau ʻo ia ka mea e pono ai ka huahana huahana:
bnds = Bounds ([0, 0, 0], [np.inf, np.inf, np.inf])A ʻo ka mea hope loa, ʻo ka manaʻo nui loa ma muli o ke kumukūʻai haʻahaʻa a me ke ʻano kiʻekiʻe, ke laina mau nei kahi laina o nā mea kūʻai aku ʻoluʻolu iā mākou. Hiki iā mākou ke koho i ka nui o ka hana o kēlā me kēia mahina, e pili ana i ka hoʻoponopono ʻana i ka pilikia optimization i kāohi ʻia me 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]E kaʻapuni mākou i nā helu holoʻokoʻa a helu i ka ukana o ka mahina o ka poʻe hoe me ka hāʻawi maikaʻi ʻana i nā huahana x = (8, 6, 3) :
- Iune:
8 * 10 + 6 * 20 + 3 * 30 = 290 чел * час; - waena:
8 * 7 + 6 * 15 + 3 * 20 = 206 чел * час; - senor:
8 * 5 + 6 * 10 + 3 * 15 = 145 чел * час.
Ka hopena: i mea e loaʻa ai i ka luna hoʻokele kāna kiʻekiʻe kūpono, ʻoi aku ka maikaʻi o ka hana ʻana i nā ʻaoʻao pae ʻāina 8, 6 mau pūnaewele waena a me 3 mau hale kūʻai i kēlā me kēia mahina. I kēia hihia, pono ka ʻelemakule e palau me ka nānā ʻole ʻana i luna mai ka mīkini, ʻo ka ukana o nā waena ma kahi o 2/3, ʻo nā juniors ma lalo o ka hapalua.
hopena
Hōʻike ka ʻatikala i nā ʻenehana kumu no ka hana ʻana me ka pūʻolo scipy.optimize, hoʻohana ʻia no ka hoʻoponopono ʻana i nā pilikia hoʻohaʻahaʻa kūlana. Hoʻohana wau pilikino scipy maʻemaʻe no nā kumu hoʻonaʻauao, ʻo ia ke kumu o ke ʻano hoʻohālike i hāʻawi ʻia.
Hiki ke loaʻa ka nui o nā kumumanaʻo a me nā hiʻohiʻona virtual, no ka laʻana, ma ka puke a I.L. Akulich "Mathematic programming in examples and problems." ʻOi aku ka palapala paʻakikī scipy.optimize e kūkulu i kahi hoʻolālā 3D mai kahi pūʻulu o nā kiʻi () hiki ke nānā ʻia ma .
ʻO ke kumu nui o ka ʻike ka poe makemake e kokua i ka unuhi ana o keia a me na pauku e ae scipy Welina mai e .
Спасибо no ke komo ʻana i ka hoʻomākaukau ʻana i ka hoʻolaha.
Source: www.habr.com