Ano ang SciPy Differential Evolution sa Python Language?
Ang Scipy ay isang mababaw, libre, at nauunawaan na library na ginagamit upang lutasin ang mga isyung pang-agham at matematika. Ang SciPy ay isang treasure box para sa mga developer dahil ang library nito ay puno ng mahahalagang module. Pinapalawak ng SciPy ang functionality ng NumPy na may mahalagang kumpol ng mga algorithm. Ang SciPy library ay may mga sub-package na maaaring gamitin para sa mga kalkulasyon, tulad ng scipy.io, scipy.optimize, atbp. Gumagawa ang SciPy ng function na 'differential evolution' at maraming makapangyarihang function sa scipy.optimize package. Ang scipy.optimize ay ginagamit para sa pag-optimize sa mga application ng Python.
Ang Differential Evolution Function ay isang pandaigdigang function na nakuha ng SciPy optimize package na ginagamit upang mahanap ang pandaigdigang minimum ng mga multivariate na function. Magagawa nitong pamahalaan ang mga multidimensional na layunin na function na hindi linear at hindi nakikilala. Ito ay isang algorithm sa paghahanap na ginagamit upang maghanap ng mga lugar ng tuluy-tuloy na mga function ng espasyo. Gumagana ang function na ito sa mga tunay na halaga.
Syntax ng Differential Evolution Function
Ang differential evolution function ay naroroon sa Python gamit ang differential_evolution () function. Ang syntax ng differential evolution function ay ipinapakita sa ibaba:
Tingnan natin ang mga parameter ng function:
Ang function ay dapat na matatawag sa f(x,*args); bounds ay tumutukoy sa pagkakasunud-sunod ng mga variable na maaaring tukuyin sa dalawang paraan: ang diskarte ay opsyonal o isang string na may default na value na 'best1bin'; ang maxiter ay opsyonal o isang int na halaga; ang popsize ay int o opsyonal; tol ay int o opsyonal; Ang mutation value ay nasa float o opsyonal; Ang recombination value ay nasa float o opsyonal; ang binhi ay wala, int, NumPy, at Random.
Sa susunod na seksyon, tatalakayin natin ang isang function ng differential evolution sa tulong ng mga madaling halimbawa.
Halimbawa 1
Magsimula tayo sa isang direktang halimbawa na magpapaunlad ng iyong interes sa pag-unawa sa konsepto ng paggana ng differential evolution. Ginamit namin ang function na differential_evolution() upang mahanap ang pinakamababang halaga. Ngunit, upang mahanap ang pinakamababang halaga, ang function ay nangangailangan ng mga hangganan sa paghahanap at isang tinukoy na matatawag na layunin ng function. Bilang resulta, tinutukoy namin ang isang function bago gamitin ang differential_evolution function sa programa. Ang reference code ng programa ay binanggit sa ibaba:
angkat numpy bilang hal.mula sa scipy angkat i-optimize
mula sa scipy. i-optimize angkat differential_evolution
angkat matplotlib. pyplot bilang py
mula sa matplotlib angkat cm
def func ( p ) :
kasama , x = p
h = hal. sqrt ( kasama si ** 4 + x ** 4 )
bumalik hal. sqrt ( h )
DE_bounds = [ [ - 6 , 6 ] , [ - 6 , 6 ] ]
res = differential_evolution ( func , DE_bounds )
print ( res )
Nag-import kami ng mga aklatan tulad ng SciPy at NumPy para sa array numerical calculations. Na-import namin ang function na differential_evolution mula sa scipy.optimize module. Pagkatapos, gamit ang keyword na 'def', tinutukoy namin ang tinatawag na layunin ng function at ipinapasa ang parameter na 'p'. Matagumpay naming tinukoy ang function na nakakahanap ng square root ng NumPy variable na karagdagan, na z, x. Ang halaga ng square root ay naka-imbak sa variable na 'h'. Ibinabalik namin ang square root value sa tinukoy na function. Ibinalik ito bilang isang argumento.
Pagkatapos nito, inaayos namin ang mga hangganan ng variable na maaaring i-itemize sa pamamagitan ng pagpapaliwanag ng min at max na halaga ng function. Isinasagawa namin ang differential_evolution function na may 'DE_bounds'' bilang argumento. Tinawag namin ang halaga ng function na may isang variable na pinangalanang res. Sa huli, ginagamit namin ang print statement upang ipakita ang output. Ang resulta ay ipinakita pagkatapos patakbuhin ang programa. Ang inaasahang output screenshot ay ipinapakita sa ibaba:
Ang Differential_evolution() ay nagpapakita na ang pinakamababang halaga ng function ay ipinapakita sa punto (0, 0).
Halimbawa 2
Ito ay isa pang halimbawa ng differential evolution function. Dito, kumukuha kami ng mga array at naglalapat ng iba't ibang operasyon sa pagitan ng mga ito. Ang reference code ng programa ay binanggit sa ibaba:
angkat numpy bilang hal.mula sa scipy angkat i-optimize
mula sa scipy. i-optimize angkat differential_evolution
def layunin_func ( d ) :
bumalik ( d [ 1 ] - 1.2 ) / 2 + 0.5 * d [ 0 ] * 1.3 * ( d [ 1 ] + 0.5 ) ** 3
_mga hangganan = [ ( - 0.3 , 0.3 ) , ( - 0.3 , 0.3 ) ]
disp = differential_evolution ( layunin_func , _mga hangganan , popsize = 80 , magpakintab = Mali )
print ( disp )
Gaya ng ipinakita sa nakaraang screenshot, matagumpay naming na-import ang SciPy.optimize.differential_evolution library at ang NumPy library sa programa. Ngayon, tinutukoy namin ang isang layunin na function sa ngalan kung saan nakita namin ang isang minimum na halaga. Naipasa namin ang mathematical expression sa objective function at nagbalik ng value bilang argumento sa tinukoy na function. Ang hangganan sa pagitan ng mga halaga ng function ay kinakailangan. Kaya, pagkatapos tukuyin ang function, inayos namin ang parehong mga halaga (maximum at minimum).
Pagkatapos tukuyin ang lahat ng mahahalagang variable, tinawag namin ang differential_evolution function upang mahanap ang pinakamababang halaga ng isang function. Na-save namin ang pinakamababang halaga ng pagbabalik ng function sa isang variable na tinatawag na disp. Sa pagtatapos ng programa, ipinapasa namin ang disp variable sa print statement upang ipakita ang resulta. Pagkatapos patakbuhin ang programa, ang pinakamababang halaga ng tinukoy na function ay ipinapakita sa screen na may mga hangganan. Ang sumusunod ay ang output:
Halimbawa 3
Tulad ng nakikita natin, ang differential evolution ay nagbabalik ng iba't ibang pinakamababang halaga ng isang layunin na function batay sa kahulugan nito. Dito, kumuha kami ng isa pang halimbawa na nauugnay sa differential_evolution(). Ang reference code para sa program na ito ay ipinapakita sa ibaba:
angkat numpy bilang hal.mula sa scipy angkat i-optimize
mula sa scipy. i-optimize angkat differential_evolution
def obj_func ( oper ) :
bumalik 3 ** 9 / 0.2 + 6 / 3 * 2 ** dalawampu
hangganan = [ ( - 0.5 , 0.5 ) , ( - 0.5 , 0.5 ) ]
palabas = differential_evolution ( obj_func , hangganan , magpakintab = totoo )
print ( 'Ang output ay:' , palabas )
Ang mga aklatan ay matagumpay na na-import sa programang ito dahil hindi namin maisagawa ang mga operasyon na gusto namin kung wala ang mga ito. Bilang resulta, isinama namin ang SciPy library sa programa. Pagkatapos nito, tukuyin ang layunin ng function na may kinakailangang operasyon. Nahanap namin ang pinakamababang halaga ng tinukoy na function. Pagkatapos ayusin ang hangganan ng function, tinawag namin ang tinukoy na function sa differential evolution upang mahanap ang pinakamababang halaga ng function. Ito ay pinananatili sa variable. Ipinapakita namin ito sa pamamagitan ng pagtawag sa variable na ito sa print statement. Ang output ng program na ito ay ipinapakita sa ibaba:
Tulad ng sa nakaraang screenshot, ang minimum na halaga ng function ay [0.29236931, 0.16808904]. Maaari mo ring patakbuhin ang mga halimbawang ito sa iyong kapaligiran upang mas maunawaan ang konsepto ng differential_evolution function.
Konklusyon
Kumuha tayo ng mabilis na pagbabalik-tanaw sa artikulong ito. Naunawaan namin ang pangunahing pag-andar ng paraan ng differential evolution na kabilang sa SciPy library sa Python. Ang Python ay ang pinakahuling wika, na may maraming flexible na aklatan. Karamihan sa mga developer ay tinulungan sa paglutas ng mga kumplikadong istruktura ng code sa pamamagitan ng mga paunang natukoy na function at library. Ang differential evolution ay isang SciPy package optimization function o paraan na ginagamit para sa minimization. Kapag ginamit mo ang mga nakaraang halimbawa sa code, mas malinaw mong nauunawaan ang konsepto ng differential evolution.