Vad är NumPy Broadcasting?
När du utför aritmetiska operationer på arrayer av olika former, refererar NumPy till detta som broadcasting. Dessa arrayoperationer utförs ofta på respektive element. Om två arrayer har samma form kan det enkelt göras på dem. Även om detta koncept är användbart, rekommenderas inte alltid sändning eftersom det kan resultera i ineffektiv minnesanvändning som saktar ner beräkningen. NumPy-operationer utförs ofta på arraypar som är uppdelade element för element.
Regler för sändning
En särskild uppsättning riktlinjer måste följas vid sändning. Dessa beskrivs nedan:
- Den lägre rankade arrayformen är viktig att ha 1:or tills båda formerna av arrayerna delar samma längd om två arrayer inte har samma rang.
- Två arrayer anses vara kompatibla om de har samma dimensionsstorlek eller om en av dem har dimensionsstorleken inställd på 1.
- Matriserna kan bara sändas tillsammans om deras storlekar och dimensioner matchar.
- När sändningen är klar, agerar varje array som om dess form matchar den för det största elementet i formen av de två inmatningsarrayerna.
- En av arrayerna beter sig som om den replikerades med den dimensionen om den andra arrayen har en dimension större än 1 och den första arrayen har dimensionen 1.
Låt oss nu diskutera några exempel på att implementera konceptet med sändning.
Exempel 1:
På par av arrayer utförs NumPy-operationer vanligtvis element för element. De två arrayerna måste, i det enklaste scenariot, ha samma form, som i exemplet nedan:
importera numpy
one_arr = numpy. array ( [ 2.0 , 3.0 , 1.0 ] )
två_arr = numpy. array ( [ 3.0 , 3.0 , 3.0 ] )
skriva ut ( en_arr * två_arr )
Som du kan se från koden ovan har vi två arrayer: 'one_arr' och 'two_ arr'. Var och en har en separat uppsättning värden. Värdena i 'one_arr' är [2.0,3.0,1.0] och 'två _arr' är [3.0,3.0,3.0]. Du kan sedan se att resultatet av att beräkna produkten av dessa två arrayer är följande:
När vissa krav uppfylls av arrayernas formulär, sänker NumPys sändningsregel denna begränsning. När en matris och ett skalärt värde sammanfogas i en operation, demonstreras sändning i sin mest grundläggande form. Som du kan se finns 3 i variabeln som heter 'two_arr.'
importera numpyone_arr = numpy. array ( [ 2.0 , 3.0 , 1.0 ] )
två_arr = 3.0
skriva ut ( en_arr * två_arr )
Ovanstående kod ger följande resultat.
I det föregående exemplet, där 'two_arr' var en array, är resultatet likvärdigt. Vi kan föreställa oss att skalären 'two_arr' expanderas under den aritmetiska processen till en array som har samma form som 'one _arr.' Arrayen 'two_arr' innehåller nya element som bara är dubbletter av den första skalären. Sträckningsjämförelsen är bara hypotetisk. För att göra sändningsoperationer så minne och beräkningsekonomiska som möjligt är NumPy smart nog att använda det ursprungliga skalära värdet istället för att producera kopior.
Exempel 2:
Här är ett annat enkelt Python-program som utför sändningar. Återigen skapas två arrayer som innehåller olika värden. Det är nödvändigt att omforma 'first_arr' till en kolumnvektor med en 3×1-form för att beräkna en yttre produkt. Efter detta utförs sändningen mot 'second_arr' för att ge ett resultat av storleken 3×2, känd som den yttre produkten av 'first_arr' och 'second_arr'. Sändning till 2×3 är möjlig eftersom 'result_arr' har formen 2 ×3 samt formen (3,).
Efter att ha följt alla ovan nämnda steg måste en vektor inkluderas i varje kolumn av matriserna som är 'result_arr' och 'second_arr.' Dessa har dimensionerna 2×3 och (2, ). Transponering av 'result_arr' kommer att ge en form på 3×2, som sedan kan sändas mot 'second_arr' för att få samma form. Vanligtvis ger transponering av detta en slutprodukt i formen 2×3.
importera numpyfirst_arr = numpy. array ( [ 12 , 24 , 14 ] )
andra_arr = numpy. array ( [ femton , 22 ] )
skriva ut ( numpy. omforma ( first_arr , ( 3 , 1 ) ) * andra_arr )
resultat_arr = numpy. array ( [ [ 12 , 22 , 31 ] , [ femton , 22 , Fyra fem ] ] )
skriva ut ( result_arr + first_arr )
skriva ut ( ( resultat_arr. T + andra_arr ) . T )
skriva ut ( result_arr + numpy. omforma ( andra_arr , ( två , 1 ) ) )
skriva ut ( resultat_arr * två )
Du kan se resultatet nedan.
Exempel 3:
En tredimensionell array kan sändas med följande Python-program. I det här exemplet har två arrayer med namnet 'first_arr' och 'second_arr' genererats. Arrayen 'first_arr' innehåller [4,13,26,12] värden och 'second_arr' innehåller [32,67,45,17] värden. Den initiala arrayens 2-dimensioner gör skillnad. Den första och andra arrayens summa kommer att visas nedan efter att koden har exekveras. Du kan se att vi har tre utskriftssatser i koden, som var och en visar texten 'Första array:', 'Second array' och 'Third array:' i tur och ordning. Summan av dessa två nygenererade arrayer visas sedan.
importera numpyfirst_arr = numpy. array ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , Fyra fem , 17 ] ] )
andra_arr = numpy. array ( [ 24 , Fyra fem , 66 , 87 ] )
skriva ut ( ' \n Första arrayen: ' )
skriva ut ( first_arr )
skriva ut ( ' \n Andra arrayen: ' )
skriva ut ( andra_arr )
skriva ut ( ' \n Summan av första och andra array: ' )
summa_result = första_arr + andra_arr ;
skriva ut ( summa_result )
Här är utdataskärmdumpen av den givna koden.
Exempel 4:
Det sista Python-programmet som sänder en tredimensionell array ges här. Två arrayer specificeras i detta program, varav den första har tre dimensioner. Den första och andra arrayens summa kommer att visas som visas ovan efter att koden har exekveras. Även om värdena i dessa arrayer varierar, är den återstående koden densamma som den som används i exempelprogrammet ovan.
importera numpyfirst_arr = numpy. array ( [ [ 12 , Fyra fem , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ femtio , 40 , 18 , 26 ] ] )
andra_arr = numpy. array ( [ 12 , 44 , 22 , 12 ] )
skriva ut ( ' \n Första arrayen: ' )
skriva ut ( first_arr )
skriva ut ( ' \n Andra arrayen: ' )
skriva ut ( andra_arr )
skriva ut ( ' \n Summan av första och andra array: ' )
summa_result = första_arr + andra_arr ;
skriva ut ( summa_result )
Du kan se i figuren nedan att en 3-dimensionell array från den första arrayen presenteras, följt av en 2-dimensionell array från den andra arrayen och resultatet av dessa två som använder sändningsprincipen.
Slutsats
Den här artikeln diskuterade sändning, ett avgörande Python-koncept. I NumPy hänvisar termen 'sändning' till kapaciteten att hantera arrayer av olika former samtidigt som man utför aritmetiska operationer som ofta utförs. Det ovannämnda ämnet har täckts ingående med en mängd olika exempel. Den här artikeln använde de nämnda exempelprogrammen för att demonstrera hur man sänder på 1-D, 2-D och 3-D-arrayer. Du kan försöka köra dessa exempel på ditt system och se resultaten för att bättre förstå hur allt fungerar i allmänhet.