ProHoster > Π‘Π»ΠΎΠ³ > wararka internetka > SciPy, hagaajin

SciPy, hagaajin

SciPy, hagaajin

SciPy (waxaa loogu dhawaaqaa sai pie) waa xirmo codsi xisaabeed oo ku saleysan kordhinta Numpy Python. Marka la adeegsanayo SciPy, fadhigaaga Python ee is dhexgalka waxa uu noqdaa isla sayniska xogta oo dhamaystiran iyo jawi qaabaynta kakan sida MATLAB, IDL, Octave, R-Lab, iyo SciLab. Maanta waxaan rabaa in aan si kooban uga hadlo sida loo isticmaalo qaar ka mid ah algorithm-ka wanaajinta si fiican loo yaqaan ee xirmada scipy.optimize. Caawimo faahfaahsan oo casri ah oo ku saabsan isticmaalka hawlaha waxaa had iyo jeer la heli karaa iyadoo la adeegsanayo amarka caawinta ama isticmaalka Shift+Tab.

Horudhac

Si aad naftaada iyo akhristayaasha uga badbaadiso raadinta iyo akhrinta ilaha aasaasiga ah, xiriirinta sharraxaadaha hababka waxay inta badan ku jiri doonaan Wikipedia. Sida caadiga ah, macluumaadkani waa ku filan si loo fahmo hababka guud ahaan iyo shuruudaha codsigooda. Si aad u fahamto nuxurka hababka xisaabta, raac xiriirinta daabacaadyo awood badan, kuwaas oo laga heli karo dhammaadka maqaal kasta ama mashiinka raadinta ee aad jeceshahay.

Markaa, moduleka scpy.optimize waxa ku jira hirgelinta hababka soo socda:

  1. Yaraynta shuruudo iyo shuruud la'aan ah ee hawlaha miisaanka leh ee doorsoomayaal dhowr ah (yar) iyadoo la adeegsanayo algorithms kala duwan (Nelder-Mead simplex, BFGS, Newton conjugate gradients, COBYLA ΠΈ SLSQP)
  2. Hagaajinta caalamiga ah (tusaale: dooxooyin, diff_evolution)
  3. Yaraynta haraaga MNC (ugu yaraan_squares) iyo algorithmaadka ku habboon qalooca iyadoo la isticmaalayo labajibbaaran aan toos ahayn (curve_fit)
  4. Yaraynta hawlaha miisaanka ee hal doorsoome (minim_scalar) iyo raadinta xididdada (root_scalar)
  5. Xalliyeyaasha kala duwan ee nidaamka isla'egta (xididka) iyagoo isticmaalaya algorithms kala duwan (Powell hybrid, Levenberg-Marquardt ama habab baaxad weyn sida Newton-Krylov).

Maqaalkan waxaan ka fiirsan doonaa oo kaliya shayga ugu horreeya ee liiskan oo dhan.

Yaraynta shuruud la'aanta ah ee shaqada scalar ee doorsoomayaal badan

Shaqada ugu yar ee ka socota xirmada scipy.optimize waxay bixisaa is-dhexgal guud oo lagu xalliyo dhibaatooyinka yaraynta shuruudaha iyo shuruud la'aanta ah ee shaqooyinka scalar ee doorsoomayaal badan. Si loo muujiyo sida ay u shaqeyso, waxaan u baahan doonaa shaqo ku habboon doorsoomayaal dhowr ah, kuwaas oo aan ku yareyn doono siyaabo kala duwan.

Ujeeddooyinkan, shaqada Rosenbrock ee doorsoomayaasha N waa mid qumman, kaas oo leh foomka:

SciPy, hagaajin

In kasta oo xaqiiqda ah in shaqada Rosenbrock iyo Jacobi iyo Hessian matrices (mida koowaad iyo labaad, siday u kala horreeyaan) ayaa mar hore lagu qeexay xirmada scipy.optimize, waxaan u qeexi doonaa nafteena.

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)

Si loo caddeeyo, aan ku sawirno 3D qiyamka shaqada Rosenbrock ee laba doorsoomayaal.

Koodhka sawirka

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()

SciPy, hagaajin

Ogaanshaha hore in ugu yaraan 0 at SciPy, hagaajin, aan eegno tusaalooyinka sida loo go'aamiyo qiimaha ugu yar ee shaqada Rosenbrock iyadoo la adeegsanayo hababka kala duwan ee scipy.optimize.

Habka fudud ee Nelder-Mead

U ogolow inuu jiro bar x0 oo ah meel 5-cabbir ah. Aynu helno meesha ugu yar ee shaqada Rosenbrock ee ugu dhow iyada oo la adeegsanayo algorithm Nelder-Mead simplex (algorithmamka waxaa lagu qeexaa sida qiimaha halbeegga habka):

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.]

Habka simplex waa habka ugu fudud ee lagu yareynayo shaqada si cad loo qeexay oo siman. Uma baahna xisaabinta waxyaabaha ka soo jeeda shaqada, waa ku filan tahay in la caddeeyo oo kaliya qiimaheeda. Habka Nelder-Mead waa doorasho wanaagsan oo loogu talagalay dhibaatooyinka yaraynta fudud. Si kastaba ha ahaatee, maadaama aysan isticmaalin qiyaasaha gradient, waxay qaadan kartaa waqti dheer in la helo ugu yaraan.

Habka Powell

Algorithm-ka wanaajinta kale ee kaliya ee qiyamka shaqada lagu xisaabiyo waa Habka Powell. Si aad u isticmaasho, waxaad u baahan tahay inaad dejiso habka = 'powell' shaqada ugu yar.

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.]

Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm

Si loo helo isu-urursi degdeg ah oo xal ah, habraaca BFS adeegsada gradient ee shaqada ujeedada. Gradient-ka waxaa lagu qeexi karaa hawl ahaan ama waxaa loo xisaabin karaa iyadoo la isticmaalayo kala duwanaanshaha amarka koowaad. Si kastaba ha ahaatee, habka BFGS wuxuu caadi ahaan u baahan yahay wicitaano hawleed ka yar habka fudud.

Aan u helno ka-soo-saarkii shaqada Rosenbrock qaab gorfayneed:

SciPy, hagaajin

SciPy, hagaajin

Eraygan waxa uu ansax u yahay dhammaan doorsoomayaasha marka laga reebo kan hore iyo kan dambe, kuwaas oo lagu qeexay sida:

SciPy, hagaajin

SciPy, hagaajin

Aynu eegno shaqada Python ee xisaabisa gradient-kan:

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

Shaqada xisaabinta gradient waxaa lagu qeexay sida qiimaha jac parameter ee shaqada ugu yar, sida hoos ku cad.

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]

Algorithm ee isku dhafka ah (Newton)

Algorithm Newton's gradients conjugates waa habka Newton oo wax laga beddelay.
Habka Newton wuxuu ku salaysan yahay qiyaasidda shaqada aagga maxalliga ah iyadoo la adeegsanayo tiro badan oo darajada labaad ah:

SciPy, hagaajin

halkaas oo SciPy, hagaajin waa jaantuska jaangooyooyinka labaad (Hessian matrix, Hessian).
Haddii Hessian-ku uu si togan u qeexan yahay, markaa waxa ugu yar ee shaqadan laga heli karaa iyada oo la barbar dhigo eber gradient ee qaabka afar-geesoodka ah ilaa eber. Natiijadu waxay noqon doontaa tibaaxaha:

SciPy, hagaajin

Hessian-ka rogan waxa lagu xisaabiyaa iyadoo la isticmaalayo habka isugaynta isku xidhka. Tusaalaha isticmaalka habkan si loo yareeyo shaqada Rosenbrock ayaa hoos lagu bixiyaa. Si aad u isticmaasho habka Newton-CG, waa in aad qeexdaa hawl xisaabisa Hessian.
Hessian ee shaqada Rosenbrock qaab gorfaynta waxay la mid tahay:

SciPy, hagaajin

SciPy, hagaajin

halkaas oo SciPy, hagaajin ΠΈ SciPy, hagaajin, qeex shaxanka SciPy, hagaajin.

Inta soo hartay ee aan eber ahayn ee shaxanka waxay la mid yihiin:

SciPy, hagaajin

SciPy, hagaajin

SciPy, hagaajin

SciPy, hagaajin

Tusaale ahaan, meel bannaan oo shan-geesood ah N = 5, jaantuska Hessian ee shaqada Rosenbrock wuxuu leeyahay qaab koox:

SciPy, hagaajin

Koodhka xisaabiya Hessian-kan oo uu weheliyo koodka lagu dhimayo shaqada Rosenbrock iyadoo la adeegsanayo habka isku xidhka (Newton):

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]

Tusaale leh qeexida shaqada sheyga ee Hessian-ka iyo vector aan sabab lahayn

Dhibaatooyinka adduunka dhabta ah, xisaabinta iyo kaydinta dhammaan shaxanka Hessian waxay u baahan karaan waqti muhiim ah iyo ilo xusuusta. Xaaladdan oo kale, dhab ahaantii looma baahna in la qeexo matrixka Hessian laftiisa, sababtoo ah Nidaamka yaraynta wuxuu u baahan yahay kaliya vector la mid ah sheyga Hessian-ka oo leh faleebo kale oo aan loo baahnayn. Sidaa darteed, marka laga eego dhinaca xisaabinta, waxaa aad loo doorbidaa in isla markiiba la qeexo shaqo ku soo celisa natiijada sheyga Hessian oo leh vector gardarro ah.

Tixgeli shaqada hess-ka, taas oo u qaadata yaraynta vector sida doodda koowaad, iyo vector gar-daran sida doodda labaad (oo ay la socoto doodaha kale ee shaqada si loo yareeyo). Xaaladeena, xisaabinta sheyga Hessian ee shaqada Rosenbrock oo leh vector aan sharci ahayn ma aha mid aad u adag. Hadii p waa vector aan sabab lahayn, ka dibna badeecada SciPy, hagaajin waxay u egtahay:

SciPy, hagaajin

Shaqada xisaabisa sheyga Hessian-ka iyo vector gar-darro ah ayaa loo gudbiyaa sida qiimaha dooda hessp si loo yareeyo shaqada:

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

Algorithm gobolka Conjugate gradient Trust (Newton)

Qaboojinta liidata ee jaantuska Hessian iyo tilmaamaha raadinta khaldan waxay sababi karaan Newton's gradient algorithm-ka inuu noqdo mid aan waxtar lahayn. Xaaladahan oo kale, doorbidid ayaa la siiyaa habka gobolka aamin (Gobolka aaminka) ee isku xidha Newton gradients.

Tusaale leh qeexida matrixka Hessian:

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.]

Tusaale leh shaqada sheyga Hessian-ka iyo fal-dambiyeedka gardarada ah:

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.]

hababka nooca Krylov

Sida habka kalsoonida-ncg, hababka nooca Krylov ayaa si fiican ugu habboon xallinta dhibaatooyinka baaxadda leh sababtoo ah waxay isticmaalaan kaliya alaabta matrix-vector. Nuxurkoodu waa inay xalliyaan dhibaatada ka jirta gobolka kalsoonida ee ay xaddidan yihiin dhul-hoosaadyada Krylov ee la jarjaray. Dhibaatooyinka aan la hubin, way fiicantahay in la isticmaalo habkan, maadaama ay isticmaasho tiro yar oo isdaba-joog ah oo aan toos ahayn sababtoo ah tirada yar ee alaabta matrix-vector per dhibaato hoose, marka la barbardhigo habka kalsoonida-ncg. Intaa waxaa dheer, xalka dhibaatada hoose ee quadratic waxaa loo helaa si sax ah marka loo eego isticmaalka habka kalsoonida-ncg.
Tusaale leh qeexida matrixka Hessian:

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.]

Tusaale leh shaqada sheyga Hessian-ka iyo fal-dambiyeedka gardarada ah:

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.]

Algorithm ee xalka qiyaasta ee gobolka kalsoonida

Dhammaan hababka (Newton-CG, trust-ncg iyo trust-krylov) waxay si fiican ugu habboon yihiin xallinta dhibaatooyinka baaxadda leh ( kumanaan doorsoomayaal ah). Tani waxay sabab u tahay xaqiiqda ah in algoorithmiyaha isku-dhafan ee hoose uu tusinayo qiyaas go'aaminta jaantuska Hessian-ga rogan. Xalka waxaa loo helaa si isdaba joog ah, iyada oo aan si cad loo balaadhin Hessian. Maadaama aad u baahan tahay oo kaliya inaad qeexdo shaqada sheyga Hessian iyo vector gar-darro ah, algorithmisku wuxuu si gaar ah ugu fiican yahay ka shaqaynta matrisyada aan badnayn (band-diagonal). Tani waxay ku siinaysaa kharash yar oo xusuusta ah iyo kayd waqti oo muhiim ah.

Dhibaatooyinka dhexdhexaadka ah, qiimaha kaydinta iyo samaynta Hessian maaha mid muhiim ah. Tani waxay ka dhigan tahay in ay suurtogal tahay in xal loo helo soo noqnoqosho yar, xallinta mashaakilaadka hoose ee gobolka kalsoonida. Si tan loo sameeyo, isla'egyada aan tooska ahayn ayaa si isdaba joog ah loogu xalliyaa dhib-hoosaad kasta. Xalka noocan oo kale ah wuxuu badanaa u baahan yahay 3 ama 4 Cholesky kala-goysyada matrixka Hessian. Natiijo ahaan, habku wuxuu isu keenaa soo noqnoqosho yar wuxuuna u baahan yahay xisaabin hawleed ka yar marka loo eego hababka kale ee kalsoonida ee gobolka. Algorithm-kani waxa uu ku lug leeyahay go'aaminta shaxanka Hessian oo dhammaystiran mana taageerto awoodda isticmaalka shaqada sheyga ee Hessian iyo vector gar-darro ah.

Tusaale leh yaraynta shaqada Rosenbrock:

res = minimize(rosen, x0, method='trust-exact',
               jac=rosen_der, hess=rosen_hess,
               options={'gtol': 1e-8, 'disp': True})
res.x

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 13
         Function evaluations: 14
         Gradient evaluations: 13
         Hessian evaluations: 14

array([1., 1., 1., 1., 1.])

Malaha halkaas ayaan ku joojinaynaa. Maqaalka soo socda waxaan isku dayi doonaa inaan u sheego waxyaalaha ugu xiisaha badan ee ku saabsan yaraynta shuruudaha, codsiga yaraynta xallinta dhibaatooyinka qiyaasaha, yaraynta shaqada hal doorsoome, yaraynta aan loo baahnayn, iyo helitaanka xididdada nidaamka isla'egta iyadoo la adeegsanayo scpy.optimize xirmo.

Source: https://docs.scipy.org/doc/scipy/reference/

Source: www.habr.com

Add a comment