SciPy (pronuntiatum sai pie) est sarcina mathematica numpy-fundata, quae etiam bibliothecas C et Fortran includit. SciPy vertit sessionem tuam interactive Python in ambitu notitiae plenae scientiarum sicut MATLAB, IDL, Octava, R, vel SciLab.
In hoc articulo spectabimus artes fundamentales programmandi mathematici - problemata optimiization conditionalis solvenda pro scalari functione plurium variabilium utentium sarcina scipy.optimize. Algorithms ipsum liberum iam dictum est . Plus detailed et up-ad-date auxilium in scipy functionibus semper obtineri potest utens adiutorium () mandatum, Shift+Tab aut in .
introduction
Commune interface ad solvendas difficultates in scipy.optimize solvendas tam conditionales quam immoderatas optimization sarcina munus. minimize(). Attamen notum est nullam esse universalem methodum solvendi omnia problemata, ita electio adaequatae methodi, ut semper in umeros incidit indagator.
Optimization conveniens algorithmus specificatur usus functionis argumentum minimize(..., method="").
Optimization conditionalis functionis plurium variabilium, praesto sunt exsecutiones sequentium methodorum:
trust-constrβ minimum locale quaerere in regione fiduciae. , ;SLSQPβ sequentem programmatio quadratica cum angustiis, methodus Newtoniana ad systema Lagrange solvendum. .TNC- Truncata Newton Coactus, numerus iterations finitus, bonum functionibus nonlinearibus cum magno variabilium independentium numero. .L-BFGS-B- methodus e quadrigis Broyden-Fletcher-Goldfarb-Shanno, adhibita consummatio memoriae reducta ob onerationem vectorum ex matrice Hessiae. , .COBYLAβ MARE Optimizationem per approximationem linearem coactam, ipsum coactum cum approximatione lineari (sine calculi gradiente). .
Secundum electum modum, condiciones et restrictiones ad problema solvendum aliter statuuntur;
- genus object
Boundsad modos L-BFGS-B, TNC, SLSQP, confide-constr; - in indice
(min, max)iisdem modis L-BFGS-B, TNC, SLSQP confidunt constr; - objectum vel album obiecti
LinearConstraint,NonlinearConstraintpro COBYLA, SLSQP, fide constr-modi; - dictionary or list of dictionary
{'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt}pro COBYLA, SLSQP modos.
Articuli adumbratio:
I) Considera usum algorithmus conditionalis optimiization in fiducia regionis (modum = "constr-constr") cum angustiis certa obiectis Bounds, LinearConstraint, NonlinearConstraint ;
II) Vide sequentem programmandi modum quadratis minimis utendi (ratio = "SLSQP") cum restrictiones certa in forma dictionary {'type', 'fun', 'jac', 'args'};
3) Analyse exemplum optimiizationis factorum factorum utens exemplo studiorum interretialium.
Optimization conditionalis method="trust-constr"
Modum exsequendam trust-constr fundatur pro quaestionibus coercitionibus formae aequalitatis pro difficultatibus angustiis in forma inaequalitatum. Ambae methodi algorithms ad effectum adducuntur ad minimum locale in fiducia regionis inveniendum et ad magnarum problematum magnarum aptissima sunt.
Formula Mathematica quaestionis de inveniendo minimum in forma generali;
Nam stricta aequalitas coercitiva, ligatus inferior superiori aequatur .
Uno modo necessitas superior vel inferior modus ponitur np.inf signo respondente.
Necessarium sit invenire minimum functionis Rosenbrock notae duarum variabilium:
Hoc in casu, restrictiones sequentes in suo regione definitionis ponuntur:
In nostro casu unica solutio est in puncto pro qua tantum prima et quarta valent restrictiones.
Eamus per restrictiones ab imo ad summum et vide quomodo eas in scipy scribere possumus.
modum ΠΈ definiamus illud utens terminis obiecti.
from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])modum ΠΈ Scribemus eam in forma lineari;
Diffinimus has angustias sicut objectum LinearConstraint:
import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])Postremo necessitas nonlinearis in forma matricis;
Definimus matricem Jacobianam in hac coactione et complexionem linearem matricis Hessiae cum vectore arbitrario. :
Nunc coercitionem nonlinearem ut objectum definire possumus 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)Si magnitudo sit magna, matrices etiam in forma sparsa specificari possunt;
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)aut objectum 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)Cum calculandum Hessiacam matrix multum laboris requirit, genere uti potes . Haec consilia praesto sunt: BFGS ΠΈ SR1.
from scipy.optimize import BFGS
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())Iniri quoque potest Hessicus finitis differentiis utentibus;
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')Matrix Jacobiana pro angustiis etiam finitis differentiis computari potest. Attamen hoc in casu matrix Hessiana finitis differentiis computari non potest. Hessicum definiri debet ut munus vel utens classi HessianUpdateStrategy.
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = '2-point', hess = BFGS ())Solutio ad ipsum problemate simile hoc spectat:
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]Si opus est, munus ad calculandum Hessiam definiri potest utens classium Linear
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)vel factum Hessicum et vectorem arbitrarium per modulum 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)Vel, prima et secunda derivationes functionis optimized approximari possunt. Exempli gratia, Hessiaco munere usus approximari potest SR1 (quasi Newtonian approximatio). Per finitas differentias approximari potest clivus.
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)Optimization conditionalis modus="SLSQP"
Methodus SLSQP ad quaestiones solvendas destinatur functionis obscuratis in forma:
quibus ΠΈ β indices vocum restrictiones in forma aequalitatum vel inaequalitatum describentium. - fines inferiores et superiores pro regione definitionis functionis.
Coactus lineares et nonlineares in forma dictionariorum cum clavium describuntur 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])
}Percontatio ad minimum hoc modo fit:
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 ]Optimization exemplum
In nexu cum transitu ad quintam structuram technologicam, inspiciamus optimization productionem adhibitis exemplis studiorum interretialium, quae parva sed stabilis reditus nos efficit. Fingamus nos rectorem triremis quae tria genera productorum producit:
- x0 - Venditionis paginae ex X tr.
- x1 - Corporate paginae ex XX tr.
- x2, ex XXX tr.
Manipulus amicae nostrae operans quattuor iuniores includit, duo media et unum seniorem. Eorum menstruum tempus fiscus working:
- Iunii:
4 * 150 = 600 ΡΠ΅Π» * ΡΠ°Ρ, - mediae;
2 * 150 = 300 ΡΠ΅Π» * ΡΠ°Ρ, - Sefi;
150 ΡΠ΅Π» * ΡΠ°Ρ.
Primus junior in promptu expendat (0, 1, 2) horas in evolutione et instruere unius speciei situs (x10, x20, x30), mediae (7, 15, 20), senior - (5, 10, 15; ) Horae vitae tuae tempus optimum.
Sicut quilibet director ordinarius, volumus lucra menstrua maximizare. Primus gradus successus est scribere munus obiectivum value ut moles reditus de producta per mensem;
def value(x):
return - 10*x[0] - 20*x[1] - 30*x[2]Non est hic error: cum maximum inquirit, munus obiectivum signo opposito elevat.
Proximum est vetare operarios nostros ab labore et restrictiones in horis operantes inducere:
Quid est aequivalens;
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]])
}Restrictio formalis est quae producti output tantum debet esse affirmativa;
bnds = Bounds ([0, 0, 0], [np.inf, np.inf, np.inf])Ac denique, assumptio maxime rosea est propter vilis pretii et qualitatem, queue satisfactum clientium semper oblinit pro nobis. Menstrua productionis volumina ipsi eligere possumus, innixa problemati optimiizationis coactae solvendo 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]Circumfluant laxe ad integros numeros et menstruum remigum onus cum optimali distributione productorum computare x = (8, 6, 3) :
- Iunii:
8 * 10 + 6 * 20 + 3 * 30 = 290 ΡΠ΅Π» * ΡΠ°Ρ; - mediae;
8 * 7 + 6 * 15 + 3 * 20 = 206 ΡΠ΅Π» * ΡΠ°Ρ; - Sefi;
8 * 5 + 6 * 10 + 3 * 15 = 145 ΡΠ΅Π» * ΡΠ°Ρ.
Conclusio: ut director maximum suum bene meritum recipiat, bene 8 paginas exscensionum creare est, 6 medium amplitudinis sites et 3 thesauros per mensem. In hoc casu, senior arare debet quin e machina spectet, mediarum sarcina circiter 2/3, minor dimidio minor erit.
conclusio,
Articulus formas praecipuas artes ad operandum cum sarcina scipy.optimize, quaestiones minimizationes conditionales solvere solebat. Personaliter utar scipy mere ad academicos usus, unde exemplum datum est talis comicae naturae.
Multum theoriae et virtutis exempla reperiri possunt, exempli gratia, in libro I.L. Akulich a "Programma Mathematica in exemplis et quaestionibus." More Hardcore application scipy.optimize 3D ex statuto imaginum structuram aedificare () Potest videri in .
Pelagus fons notitia est ad translationem huius et aliarum sectionum conferre volentes scipy Grata to .
Π‘ΠΏΠ°ΡΠΈΠ±ΠΎ ad participationem in praeparatione publicationis.
Source: www.habr.com