Ano ang NumPy Broadcasting?
Kapag nagsasagawa ng mga pagpapatakbo ng aritmetika sa mga array ng iba't ibang anyo, tinutukoy ito ng NumPy bilang pagsasahimpapawid. Ang mga operasyon ng array na ito ay madalas na isinasagawa sa kani-kanilang mga elemento. Kung ang dalawang array ay may parehong hugis, maaari itong gawin sa kanila nang madali. Kahit na kapaki-pakinabang ang konseptong ito, hindi palaging inirerekomenda ang pagsasahimpapawid dahil maaari itong magresulta sa hindi mahusay na paggamit ng memorya na nagpapabagal sa pagkalkula. Ang mga operasyon ng NumPy ay madalas na ginagawa sa mga pares ng array na pinaghiwa-hiwalay na elemento ayon sa elemento.
Mga Panuntunan sa Pag-broadcast
Dapat sundin ang isang partikular na hanay ng mga alituntunin kapag nagbo-broadcast. Ang mga ito ay inilarawan sa ibaba:
- Ang hugis ng array na mas mababang ranggo ay mahalaga na malagyan ng 1s hanggang sa magkapareho ang haba ng parehong mga hugis ng array kung walang parehong ranggo ang dalawang array.
- Itinuturing na magkatugma ang dalawang array kung magkapareho ang sukat ng mga ito o kung ang isa sa mga ito ay may sukat ng dimensyon na nakatakda sa 1.
- Maaari lang i-broadcast nang magkasama ang mga array kung magkatugma ang mga laki at dimensyon ng mga ito.
- Kapag kumpleto na ang pagsasahimpapawid, ang bawat array ay kumikilos na parang tumutugma ang anyo nito sa pinakamalaking elemento sa mga hugis ng dalawang input array.
- Ang isa sa mga array ay kumikilos na parang kinopya ito sa dimensyong iyon kung ang isa pang array ay may dimensyon na higit sa 1 at ang unang array ay may dimensyon na 1.
Ngayon, talakayin natin ang ilang halimbawa ng pagpapatupad ng konsepto ng pagsasahimpapawid.
Halimbawa 1:
Sa mga pares ng mga array, ang mga pagpapatakbo ng NumPy ay karaniwang isinasagawa sa bawat elemento. Ang dalawang array ay dapat, sa pinakasimpleng senaryo, ay may parehong hugis, tulad ng sa halimbawa sa ibaba:
angkat numpy
one_arr = numpy. array ( [ 2.0 , 3.0 , 1.0 ] )
dalawang_arr = numpy. array ( [ 3.0 , 3.0 , 3.0 ] )
print ( isa_arr * dalawa_arr )
Gaya ng nakikita mo mula sa code sa itaas, mayroon kaming dalawang array: ‘one_arr’ at ‘two_ arr’. Ang bawat isa ay may hiwalay na hanay ng mga halaga. Ang mga value sa ‘one_arr’ ay [2.0,3.0,1.0] at ‘two _arr’ ay [3.0,3.0,3.0]. Pagkatapos ay makikita mo na ang resulta ng pagkalkula ng produkto ng dalawang array na ito ay ang mga sumusunod:
Kapag natugunan ng mga form ng array ang ilang partikular na kinakailangan, pinabababa ng panuntunan sa pagsasahimpapawid ng NumPy ang paghihigpit na ito. Kapag ang isang array at isang scalar value ay pinagsama sa isang operasyon, ang pagsasahimpapawid ay ipinapakita sa pinakapangunahing anyo nito. Tulad ng nakikita mo, ang 3 ay nakapaloob sa variable na pinangalanang 'two_arr.'
angkat numpyone_arr = numpy. array ( [ 2.0 , 3.0 , 1.0 ] )
dalawang_arr = 3.0
print ( isa_arr * dalawa_arr )
Ang code sa itaas ay gumagawa ng sumusunod na resulta.
Sa naunang halimbawa, kung saan ang 'two_arr' ay isang array, ang kinalabasan ay katumbas. Maaari naming isipin ang scalar na 'two_arr' na pinalawak sa panahon ng proseso ng aritmetika sa isang array na may parehong hugis bilang 'one _arr.' Ang array na 'two_arr' ay naglalaman ng mga bagong elemento na mga duplicate lang ng unang scalar. Ang lumalawak na paghahambing ay hypothetical lamang. Upang gawing memorya ang mga pagpapatakbo ng pagsasahimpapawid at matipid sa pagkalkula bilang magagawa, sapat na matalino ang NumPy upang gamitin ang orihinal na halaga ng scalar kaysa sa paggawa ng mga kopya.
Halimbawa 2:
Narito ang isa pang simpleng Python program na nagsasagawa ng pagsasahimpapawid. Muli, dalawang array ang nilikha na naglalaman ng magkakaibang mga halaga. Kinakailangang i-reshape ang 'first_arr' sa isang column vector na may 3x1 na hugis upang makalkula ang isang panlabas na produkto. Kasunod nito, ang pagsasahimpapawid ay isinagawa laban sa 'second_arr' upang magbigay ng resulta ng sukat na 3×2, na kilala bilang panlabas na produkto ng 'first_arr' at 'second_arr.' Posible ang pagsasahimpapawid sa 2×3 dahil ang 'result_arr' ay may hugis 2 ×3 pati na rin ang hugis (3,).
Pagkatapos sundin ang lahat ng nabanggit na hakbang, dapat na may kasamang vector sa bawat column ng mga matrice na 'result_arr' at 'second_arr.' Ang mga ito ay may sukat na 2×3 at (2, ). Ang paglipat ng 'result_arr' ay magbubunga ng hugis na 3×2, na maaaring i-broadcast laban sa 'second_arr' upang makuha ang parehong form. Karaniwan, ang transposing nito ay magbubunga ng pangwakas na produkto sa hugis na 2×3.
angkat numpyfirst_arr = numpy. array ( [ 12 , 24 , 14 ] )
second_arr = numpy. array ( [ labinlima , 22 ] )
print ( numpy. muling hugis ( first_arr , ( 3 , 1 ) ) * second_arr )
resulta_arr = numpy. array ( [ [ 12 , 22 , 31 ] , [ labinlima , 22 , Apat. Lima ] ] )
print ( resulta_arr + first_arr )
print ( ( resulta_arr. T + second_arr ) . T )
print ( resulta_arr + numpy. muling hugis ( second_arr , ( dalawa , 1 ) ) )
print ( resulta_arr * dalawa )
Maaari mong tingnan ang output sa ibaba.
Halimbawa 3:
Maaaring mai-broadcast ang isang three-dimensional array gamit ang sumusunod na programang Python. Sa halimbawang ito, dalawang array na pinangalanang 'first_arr' at 'second_arr' ang nabuo. Ang array na 'first_arr' ay naglalaman ng [4,13,26,12] value at 'second_arr' ay naglalaman ng [32,67,45,17] value. May pagkakaiba ang 2-dimension ng paunang array. Ang kabuuan ng una at pangalawang array ay ipapakita sa ibaba pagkatapos na maisakatuparan ang code. Makikita mo na mayroon kaming tatlong print statement sa code, bawat isa ay nagpapakita ng text na 'Unang array:', 'Second array', at 'Third array:' sa turn. Pagkatapos ay ipapakita ang kabuuan ng dalawang bagong nabuong array na ito.
angkat numpyfirst_arr = numpy. array ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , Apat. Lima , 17 ] ] )
second_arr = numpy. array ( [ 24 , Apat. Lima , 66 , 87 ] )
print ( ' \n Unang hanay: ' )
print ( first_arr )
print ( ' \n Pangalawang hanay: ' )
print ( second_arr )
print ( ' \n Kabuuan ng una at pangalawang hanay: ' )
sum_result = first_arr + second_arr ;
print ( sum_result )
Narito ang output screenshot ng ibinigay na code.
Halimbawa 4:
Ang huling Python program na nagbo-broadcast ng three-dimensional array ay ibinibigay dito. Dalawang array ang tinukoy sa program na ito, ang una ay may tatlong dimensyon. Ang kabuuan ng una at pangalawang array ay ipapakita tulad ng ipinapakita sa itaas pagkatapos na maisakatuparan ang code. Bagama't iba-iba ang mga value sa mga array na ito, ang natitirang code ay kapareho ng ginamit sa halimbawang program sa itaas.
angkat numpyfirst_arr = numpy. array ( [ [ 12 , Apat. Lima , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ limampu , 40 , 18 , 26 ] ] )
second_arr = numpy. array ( [ 12 , 44 , 22 , 12 ] )
print ( ' \n Unang hanay: ' )
print ( first_arr )
print ( ' \n Pangalawang hanay: ' )
print ( second_arr )
print ( ' \n Kabuuan ng una at pangalawang hanay: ' )
sum_result = first_arr + second_arr ;
print ( sum_result )
Makikita mo sa figure sa ibaba na ipinakita ang isang 3-dimensional na array mula sa unang array, na sinusundan ng isang 2-dimensional na array mula sa pangalawang array at ang resulta ng dalawang ito na gumagamit ng prinsipyo ng pagsasahimpapawid.
Konklusyon
Tinalakay ng artikulong ito ang pagsasahimpapawid, isang mahalagang konsepto ng Python. Sa NumPy, ang terminong 'pagsasahimpapawid' ay tumutukoy sa kakayahang pangasiwaan ang mga arrays ng iba't ibang mga hugis habang nagsasagawa ng mga operasyong aritmetika na madalas na ginagawa. Ang nabanggit na paksa ay lubusang tinakpan ng iba't ibang mga halimbawa. Ginamit ng artikulong ito ang nabanggit na mga halimbawang programa upang ipakita kung paano mag-broadcast sa 1-D, 2-D, at 3-D array, ayon sa pagkakabanggit. Maaari mong subukang patakbuhin ang mga halimbawang ito sa iyong system at tingnan ang mga resulta upang mas maunawaan kung paano gumagana ang lahat sa pangkalahatan.