Hvad er NumPy Broadcasting?
Når du udfører aritmetiske operationer på arrays af forskellige former, refererer NumPy til dette som broadcasting. Disse array-operationer udføres ofte på de respektive elementer. Hvis to arrays har samme form, kan det nemt gøres på dem. Selvom dette koncept er nyttigt, anbefales udsendelse ikke altid, fordi det kan resultere i ineffektiv hukommelsesbrug, der sænker beregningen. NumPy-operationer udføres ofte på array-par, der er opdelt element for element.
Regler for udsendelse
Et bestemt sæt retningslinjer skal følges ved udsendelse. Disse er beskrevet nedenfor:
- Det er vigtigt, at den lavere rangordnede array-form sættes foran med 1'ere, indtil begge former for arrays deler samme længde, hvis to arrays ikke har samme rang.
- To arrays anses for at være kompatible, hvis de har samme dimensionsstørrelse, eller hvis en af dem har dimensionsstørrelsen indstillet til 1.
- Arrays kan kun udsendes sammen, hvis deres størrelser og dimensioner matcher.
- Når udsendelsen er færdig, virker hvert array, som om dets form matcher det største elements form i form af de to input-arrays.
- Et af arrays opfører sig, som om det var replikeret med den dimension, hvis det andet array har en dimension større end 1, og det første array har en dimension på 1.
Lad os nu diskutere nogle eksempler på implementering af begrebet udsendelse.
Eksempel 1:
På par af arrays udføres NumPy-operationer typisk element-for-element. De to arrays skal i det mest ligetil scenario have samme form som i eksemplet nedenfor:
importere nusset
one_arr = nusset. array ( [ 2.0 , 3.0 , 1.0 ] )
to_arr = nusset. array ( [ 3.0 , 3.0 , 3.0 ] )
Print ( en_arr * to_arr )
Som du kan se fra koden ovenfor, har vi to arrays: 'one_arr' og 'two_ arr'. Hver af dem har et separat sæt værdier. Værdierne i 'one_arr' er [2.0,3.0,1.0] og 'to _arr' er [3.0,3.0,3.0]. Du kan så se, at resultatet af beregningen af produktet af disse to arrays er som følger:
Når visse krav opfyldes af arrayernes formularer, sænker NumPys udsendelsesregel denne begrænsning. Når et array og en skalarværdi kombineres i en operation, demonstreres udsendelse i sin mest grundlæggende form. Som du kan se, er 3 indeholdt i variablen ved navn 'two_arr.'
importere nussetone_arr = nusset. array ( [ 2.0 , 3.0 , 1.0 ] )
to_arr = 3.0
Print ( en_arr * to_arr )
Ovenstående kode giver følgende resultat.
I det foregående eksempel, hvor 'two_arr' var et array, er resultatet ækvivalent. Vi kan forestille os, at skalaren 'two_arr' udvides under den aritmetiske proces til en matrix med samme form som 'one _arr.' Arrayen 'two_arr' indeholder nye elementer, der blot er duplikater af den første skalar. Stræksammenligningen er blot hypotetisk. For at gøre udsendelsesoperationer så hukommelse og beregningsøkonomiske som muligt, er NumPy smart nok til at bruge den originale skalarværdi i stedet for at producere kopier.
Eksempel 2:
Her er et andet simpelt Python-program, der udfører udsendelser. Endnu en gang oprettes to arrays med forskellige værdier. Det er nødvendigt at omforme 'first_arr' til en kolonnevektor med en 3×1 form for at beregne et ydre produkt. Efter dette udføres udsendelsen mod 'second_arr' for at give et resultat af størrelsen 3×2, kendt som det ydre produkt af 'first_arr' og 'second_arr.' Udsendelse til 2×3 er muligt, da 'result_arr' har formen 2 ×3 samt formen (3,).
Efter at have fulgt alle de ovennævnte trin, skal en vektor inkluderes i hver kolonne af matricerne, som er 'result_arr' og 'second_arr.' Disse har dimensioner på 2×3 og (2, ). Transponering af 'result_arr' vil give en form på 3×2, som derefter kan udsendes mod 'second_arr' for at få den samme form. Typisk giver transponering af dette et slutprodukt i formen 2×3.
importere nussetførste_arr = nusset. array ( [ 12 , 24 , 14 ] )
anden_arr = nusset. array ( [ femten , 22 ] )
Print ( nusset. omforme ( første_arr , ( 3 , 1 ) ) * anden_arr )
resultat_arr = nusset. array ( [ [ 12 , 22 , 31 ] , [ femten , 22 , Fire, fem ] ] )
Print ( resultat_arr + første_arr )
Print ( ( resultat_arr. T + second_arr ) . T )
Print ( result_arr + numpy. omforme ( anden_arr , ( to , 1 ) ) )
Print ( resultat_arr * to )
Du kan se outputtet nedenfor.
Eksempel 3:
Et tredimensionelt array kan udsendes ved hjælp af følgende Python-program. I dette eksempel er to arrays med navnet 'first_arr' og 'second_arr' blevet genereret. Arrayet 'first_arr' indeholder [4,13,26,12] værdier og 'second_arr' indeholder [32,67,45,17] værdier. Det indledende arrays 2-dimensioner gør en forskel. Summen af det første og andet array vises nedenfor, efter at koden er blevet eksekveret. Du kan se, at vi har tre udskriftsudsagn i koden, som hver viser teksten 'First array:', 'Second array' og 'Third array:' på skift. Summen af disse to nyligt genererede arrays vises derefter.
importere nussetførste_arr = nusset. array ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , Fire, fem , 17 ] ] )
anden_arr = nusset. array ( [ 24 , Fire, fem , 66 , 87 ] )
Print ( ' \n Første array: ' )
Print ( første_arr )
Print ( ' \n Andet array: ' )
Print ( anden_arr )
Print ( ' \n Summen af første og anden matrix: ' )
sum_result = first_arr + second_arr ;
Print ( sum_result )
Her er output-skærmbilledet af den givne kode.
Eksempel 4:
Det sidste Python-program, der udsender et tredimensionelt array, er angivet her. To arrays er specificeret i dette program, hvoraf den første har tre dimensioner. Det første og andet arrays sum vil blive vist som vist ovenfor, efter at koden er blevet eksekveret. Selvom værdierne i disse arrays varierer, er den resterende kode den samme som den, der blev brugt i eksempelprogrammet ovenfor.
importere nussetførste_arr = nusset. array ( [ [ 12 , Fire, fem , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ halvtreds , 40 , 18 , 26 ] ] )
anden_arr = nusset. array ( [ 12 , 44 , 22 , 12 ] )
Print ( ' \n Første array: ' )
Print ( første_arr )
Print ( ' \n Andet array: ' )
Print ( anden_arr )
Print ( ' \n Summen af første og anden matrix: ' )
sum_result = first_arr + second_arr ;
Print ( sum_result )
Du kan se i figuren nedenfor, at et 3-dimensionelt array fra det første array er præsenteret, efterfulgt af et 2-dimensionelt array fra det andet array og resultatet af disse to, der anvender udsendelsesprincippet.
Konklusion
Denne artikel diskuterede broadcasting, et afgørende Python-koncept. I NumPy refererer udtrykket 'broadcasting' til kapaciteten til at håndtere arrays af forskellige former, mens du udfører aritmetiske operationer, der ofte udføres. Det førnævnte emne er blevet grundigt dækket med en række eksempler. Denne artikel brugte de nævnte eksempelprogrammer til at demonstrere, hvordan man udsender på henholdsvis 1-D, 2-D og 3-D-arrays. Du kan prøve at køre disse eksempler på dit system og se resultaterne for bedre at forstå, hvordan alt fungerer generelt.