SciPy (waxaa loogu dhawaaqaa sai pie) waa xirmo xisaabeed nambaro ku saleysan oo ay ku jiraan maktabadaha C iyo Fortran. SciPy waxay u beddeshaa fadhigaaga isdhexgalka ee Python jawi xogeed oo dhamaystiran sida MATLAB, IDL, Octave, R, ama SciLab.
Maqaalkan, waxaan ku eegi doonaa farsamooyinka aasaasiga ah ee barnaamijka xisaabinta - xallinta mashaakilaadka hagaajinta shuruudaha ee shaqada scalar ee doorsoomayaal dhowr ah iyadoo la adeegsanayo xirmada scipy.optimize. Algorithms-ka hagaajinta aan xadidnayn ayaa mar hore lagaga hadlay . Caawimo faahfaahsan oo cusub oo ku saabsan hawlaha scipy ayaa had iyo jeer la heli karaa iyada oo la adeegsanayo amarka caawinta, Shift+Tab ama gudaha .
Horudhac
Isku-xidhka guud ee lagu xalliyo mashaakilaadka hagaajinta shuruudaysan iyo kuwa aan xaddidnayn ee ku jira xirmada scipy.optimize waxaa bixiya shaqada minimize(). Si kastaba ha ahaatee, waxaa la og yahay in aysan jirin hab caalami ah oo lagu xalliyo dhammaan dhibaatooyinka, sidaas darteed doorashada hab ku filan, sida had iyo jeer, waxay ku dhacdaa garbaha cilmi-baarayaasha.
Algorithm hagaajinta ku habboon ayaa lagu qeexay iyadoo la adeegsanayo doodda shaqada minimize(..., method="").
Si loo hagaajiyo shuruudaha doorsoomayaasha kala duwan, hirgelinta hababka soo socda ayaa diyaar ah:
trust-constr- ka raadi ugu yaraan degaanka ee gobolka kalsoonida. , ;SLSQP-Barnaamij afar geesle ah oo isdabajoog ah oo leh caqabado, habka Newtonian ee lagu xalliyo nidaamka Lagrange. .TNC- Newton Constrained, tirada xaddidan ee ku celcelinta, oo u fiican hawlaha aan tooska ahayn oo leh tiro badan oo doorsoomayaal madaxbannaan. .L-BFGS-B- hab ka yimid kooxda Broyden-Fletcher-Goldfarb-Shanno, oo lagu hirgeliyay isticmaalka xusuusta oo yaraatay iyadoo ay ugu wacan tahay qayb ka mid ah vectors oo ka yimid jaantuska Hessian. , .COBYLA- MARE Cusboonaysiinta Xakamaysan Qiyaasta toosan, hagaajinta xaddidan oo leh qiyaas toosan (la'aan xisaabin tartiib tartiib ah). .
Iyadoo ku xiran habka la doortay, shuruudaha iyo xaddidaadaha xallinta dhibaatada ayaa loo dejiyay si kala duwan:
- shayga fasalka
Boundshababka L-BFGS-B, TNC, SLSQP, kalsoonida-constr; - liiska
(min, max)hababka isku midka ah ee L-BFGS-B, TNC, SLSQP, trust-constr; - shay ama liiska walxaha
LinearConstraint,NonlinearConstraintloogu talagalay COBYLA, SLSQP, hababka isku-kalsoonida; - qaamuuska ama liiska qaamuusyada
{'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt}loogu talagalay COBYLA, hababka SLSQP.
dulmar maqaalka:
1) Tixgeli adeegsiga algorithm hagaajinta shuruudaha ee gobolka kalsoonida (hab = "trust-constr") oo leh caqabado lagu tilmaamay walxo Bounds, LinearConstraint, NonlinearConstraint ;
2) Tixgeli barnaamijyada isku xigxiga adoo isticmaalaya habka ugu yar ee afar geesoodka ah (hab = "SLSQP") oo leh xaddidaadyo lagu qeexay qaabka qaamuuska. {'type', 'fun', 'jac', 'args'};
3) Falanqee tusaalaha hagaajinta alaabta la soo saaray iyadoo la isticmaalayo tusaale ahaan istuudiyaha shabakadda.
Habka wanaajinta shuruuda ah="trust-constr"
Hirgelinta habka trust-constr ku salaysan dhibaatooyinka ka haysta caqabadaha qaabka sinnaanta iyo ku dhibaatooyinka haysta caqabadaha qaabka sinnaan la'aanta. Labada habba waxaa lagu fuliyaa algorithms si loo helo ugu yaraan degaanka ee gobolka kalsoonida waxayna si fiican ugu habboon yihiin dhibaatooyinka baaxadda leh.
Samaynta xisaabta ee dhibaatada helitaanka ugu yaraan qaab guud:
Caqabadaha adag ee sinnaanta, soohdinta hoose waxaa loo dejiyay mid la mid ah xadka sare 
.
Xayiraadda hal dhinac ah, xadka sare ama hoose ayaa la dejiyay np.inf oo leh calaamad u dhiganta.
U ogolow inay lagama maarmaan noqoto in la helo ugu yar ee shaqada Rosenbrock ee la yaqaan ee laba doorsoomayaal:
Xaaladdan oo kale, xaddidaadaha soo socda ayaa lagu dejiyay goobta qeexitaanka:
Xaaladeena, waxaa jira xal u gaar ah barta 
, kuwaas oo kaliya xayiraadaha koowaad iyo afaraad ay ansax yihiin.
Aynu ka gudubno xannibaadaha hoos ilaa sare oo aynu eegno sida aan u qori karno si scipy ah.
Xaddidaadda 
ΠΈ 
aynu ku qeexno anagoo adeegsanayna shayga Soohdinta.
from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])Xaddidaadda 
ΠΈ 
Aan u qorno qaab toosan:
Aynu qeexno caqabadahan inay yihiin shay LinearConstraint:
import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])Iyo ugu dambeyntii xannibaadda aan tooska ahayn ee qaabka matrixka:
Waxaan u qeexnay jaantuska Jacobian xannibaaddan iyo isku darka toosan ee shaxanka Hessian oo leh vector aan sabab lahayn. 
:
Hadda waxaan ku qeexi karnaa xannibaad aan toos ahayn shay 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)Haddii cabbirku weyn yahay, matries sidoo kale waxaa lagu qeexi karaa qaab yar:
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)ama shay ahaan 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)Marka la xisaabinayo matrixka Hessian 
waxay u baahan tahay dadaal badan, waxaad isticmaali kartaa fasal . Xeeladaha soo socda ayaa diyaar ah: BFGS ΠΈ SR1.
from scipy.optimize import BFGS
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())Hessian-ka waxa kale oo lagu xisaabin karaa iyadoo la isticmaalayo kala duwanaansho kooban:
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')Matrixka Jacobian ee xannibaadaha ayaa sidoo kale lagu xisaabin karaa iyadoo la adeegsanayo kala duwanaansho xaddidan. Si kastaba ha ahaatee, kiiskan Hessian matrixka laguma xisaabin karo iyada oo la adeegsanayo kala duwanaansho xaddidan. Hessian-ka waa in lagu qeexaa hawl ama adeegsiga fasalka HessianUpdate Strategy.
nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = '2-point', hess = BFGS ())Xalka dhibaatada hagaajinta waxay u egtahay sidan:
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]Haddii loo baahdo, shaqada xisaabinta Hessian waxaa lagu qeexi karaa iyadoo la isticmaalayo fasalka 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)ama sheyga Hessian-ka iyo vector aan sabab lahayn oo loo maro cabbirka 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)Beddel ahaan, soosaarayaasha koowaad iyo labaad ee shaqada la hagaajiyay waa la qiyaasi karaa. Tusaale ahaan, Hessian-ka waxaa lagu qiyaasi karaa iyadoo la isticmaalayo shaqada SR1 (qiyaastii-Newtonian). Jaangooyooyinka waxaa lagu qiyaasi karaa kala duwanaansho xaddidan.
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)Habka wanaajinta shuruuda = "SLSQP"
Habka SLSQP waxaa loogu talagalay in lagu xalliyo mashaakilaadka yaraynta shaqada qaabka:
Xagee 
ΠΈ 
- tibaaxaha tusmooyinka odhaahyada qeexaya xannibaadaha qaabka sinnaanta ama sinnaan la'aanta. 
- dejinta xuduudaha hoose iyo sare ee goobta qeexida shaqada.
Xayiraadaha tooska ah iyo kuwa aan tooska ahayn ayaa lagu sifeeyay qaab qaamuusyo leh furayaal 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])
}Raadinta ugu yar ayaa loo fuliyaa sida soo socota:
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 ]Tusaalaha Hagaajinta
Marka la eego u gudubka qaabdhismeedka tignoolajiyada shanaad, aynu ka fikirno hagaajinta wax soo saarka anagoo adeegsanayna tusaale ahaan istuudiyaha webka, kaas oo noo keena dakhli yar laakiin xasilloon. Aan ku qiyaasno nafteena in aan nahay maamulaha galley soo saarta saddex nooc oo badeecooyin ah:
- x0 - iibinta bogagga degitaanka, laga bilaabo 10 tr.
- x1 - shabakadaha shirkadaha, laga bilaabo 20 tr.
- x2 - dukaamada khadka tooska ah, laga bilaabo 30 tr.
Kooxdayada shaqo ee saaxiibtinimada leh waxa ka mid ah afar junior, laba dhexe iyo mid sare. Khasnadda wakhtiga shaqada ee bisha:
- Juunyo:
4 * 150 = 600 ΡΠ΅Π» * ΡΠ°Ρ, - dhexda:
2 * 150 = 300 ΡΠ΅Π» * ΡΠ°Ρ, - senator:
150 ΡΠ΅Π» * ΡΠ°Ρ.
U ogolow ilmaha ugu horreeya ee la heli karo (0, 1, 2) saacadood horumarinta iyo geynta hal goob oo nooc ah (x10, x20, x30), dhexe - (7, 15, 20), sare - (5, 10, 15) ) saacadaha wakhtiga ugu fiican noloshaada.
Sida agaasime kasta oo caadi ah, waxaan rabnaa inaan sare u qaadno faa'iidada bisha. Talaabada ugu horeysa ee guusha waa in la qoro shaqada ujeedada value sida xadiga dakhliga ka soo gala alaabta la soo saaro bishii:
def value(x):
return - 10*x[0] - 20*x[1] - 30*x[2]Tani maaha qalad; marka la raadinayo ugu badnaan, shaqada ujeedadu waa la yareeyaa calaamad ka soo horjeeda.
Tallaabada xigta waa inaan ka mamnuucno shaqaalaheenna inay shaqeeyaan si xad-dhaaf ah oo aan u soo bandhigno xaddidaadyo saacadaha shaqada:
Maxaa u dhigma:
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]])
}Xayiraadda rasmiga ah waa in wax-soo-saarka badeecadu uu ahaado mid togan:
bnds = Bounds ([0, 0, 0], [np.inf, np.inf, np.inf])Ugu dambayntii, malo-awaalka ugu quruxda badan ayaa ah in qiimaha hooseeya iyo tayada sare awgeed, safka macaamiishu ku qanacsan yihiin ayaa si joogto ah noogu soo jira. Waxaan dooran karnaa mugga wax soo saarka bilaha ah nafteena, iyadoo ku saleysan xallinta dhibaatada hagaajinta ee xaddidan 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]Aan si dabacsan ugu soo koobno ββtirooyinka oo dhan oo aan ku xisaabinno culeyska doomoyaasha bishiiba iyadoo si wanaagsan loo qaybinayo x = (8, 6, 3) :
- Juunyo:
8 * 10 + 6 * 20 + 3 * 30 = 290 ΡΠ΅Π» * ΡΠ°Ρ; - dhexda:
8 * 7 + 6 * 15 + 3 * 20 = 206 ΡΠ΅Π» * ΡΠ°Ρ; - senator:
8 * 5 + 6 * 10 + 3 * 15 = 145 ΡΠ΅Π» * ΡΠ°Ρ.
Gabagabo: si uu agaasimuhu u helo ugu badnaantii uu xaqa u lahaa, waxa fiican in la sameeyo 8 bog oo deg deg ah, 6 goobood oo dhexdhexaad ah iyo 3 dukaan bishiiba. Xaaladdan oo kale, waayeelku waa inuu xaaqaa isagoo aan kor ka eegayn mashiinka, culeyska dhexda ayaa noqon doona qiyaastii 2/3, da'yarta wax ka yar kala badh.
gunaanad
Maqaalku wuxuu qeexayaa farsamooyinka aasaasiga ah ee la shaqeynta xirmada scipy.optimize, loo isticmaalo in lagu xalliyo dhibaatooyinka yaraynta shuruudaha. Shakhsi ahaan waan isticmaalaa scipy oo keliya ujeeddooyin tacliimeed, taas oo ah sababta tusaalaha la bixiyay uu u yahay dabeecad majaajillo ah.
Tusaalayaal badan oo aragti iyo muuqaal ah ayaa laga heli karaa, tusaale ahaan, buugga IL Akulich "Barnaamijka xisaabta ee tusaalooyinka iyo dhibaatooyinka." Codsi adag oo badan scipy.optimize in la dhiso qaab dhismeedka 3D oo laga soo qaaday sawirro () waa laga eegi karaa .
Isha ugu weyn ee macluumaadka waa kuwa raba inay ka qaybqaataan tarjumaada tan iyo qaybaha kale scipy Ku soo DHAWOOW .
Π‘ΠΏΠ°ΡΠΈΠ±ΠΎ ka qayb qaadashada diyaarinta daabacaadda.
Source: www.habr.com
