Numpy kringkasting

Arrays av forskjellige størrelser kan ikke legges til, trekkes fra eller på annen måte brukt i aritmetikk. Duplisering av utvalget av små for å gi den samme dimensjoner og størrelse som den større matrisen er en tilnærming. Når du gjennomfører array aritmetikk, tilbyr Numpy en funksjon kjent som Array Broadcasting som kan forkorte og forenkle koden din betydelig. Du vil lære om ideen om array kringkasting og hvordan du bruker den i Numpy i denne opplæringen. I tillegg er det gitt flere eksempelprogrammer.

Hva er numpy kringkasting?

Når du utfører aritmetiske operasjoner på matriser med forskjellige former, omtaler Numpy dette som kringkasting. Disse matriseoperasjonene utføres ofte på de respektive elementene. Hvis to matriser har samme form, kan det gjøres på dem med letthet. Selv om dette konseptet er nyttig, anbefales ikke alltid kringkasting fordi det kan resultere i ineffektiv minnebruk som bremser beregningen. Numpy operasjoner utføres ofte på matrisepar som er nedbrutt element etter element.

Regler for kringkasting

Et bestemt sett med retningslinjer må følges ved kringkasting. Disse er beskrevet nedenfor:

1. Formen for lavere rangering er viktig for å bli forhåndsbetalt med 1s til begge former på matriser har samme lengde hvis to matriser ikke har samme rangering.
2. To matriser anses å være kompatible hvis de har samme dimensjonsstørrelse, eller hvis en av dem har dimensjonsstørrelsen satt til 1.
3. Arraysene kan bare sendes sammen hvis deres størrelser og dimensjoner stemmer overens.
4. Når kringkastingen er fullført, fungerer hver matrise som om skjemaet samsvarer med det største elementet i formene til de to inngangsarraysene.
5. En av matriser oppfører seg som om den ble replikert med den dimensjonen hvis den andre matrisen har en dimensjon større enn 1 og den første matrisen har en dimensjon på 1.

La oss nå diskutere noen eksempler på å implementere konseptet kringkasting.

Eksempel 1:

På par matriser utføres numpy operasjoner typisk element-for-element. De to matriser må i det mest enkle scenariet ha samme form, som i eksemplet nedenfor:

Importer numpy
One_arr = numpy.Array ([2.0, 3.0, 1.0])
to_arr = numpy.Array ([3.0, 3.0, 3.0])
trykk (One_arr * TO_ARR)

Som du ser fra koden over, har vi to matriser: 'One_arr' og 'Two_ arr'. Som hver har et eget sett med verdier. Verdiene i 'One_arr' er [2.0,3.0,1.0] og 'to _arr' er [3.0,3.0,3.0]. Du kan da se at resultatet av beregning av produktet av disse to matriser er som følger:

Når visse krav blir oppfylt av matrisernes skjemaer, senker Numpys kringkastingsregel denne begrensningen. Når en matrise og en skalarverdi er sammen med en operasjon, demonstreres kringkasting i sin mest grunnleggende form. Som du ser er 3 inneholdt i variabelen som heter 'Two_arr.'

Importer numpy
One_arr = numpy.Array ([2.0, 3.0, 1.0])
to_arr = 3.0
trykk (One_arr * TO_ARR)

Ovennevnte kode gir følgende resultat.

I det foregående eksemplet, der 'Two_arr' var en matrise, tilsvarer utfallet. Vi kan se på at skalaren 'Two_arr' blir utvidet under den aritmetiske prosessen til en matrise som har samme form som 'One _ARR.'The Array' to_arr 'inneholder nye elementer som bare er duplikater av den første skalaren. Strekkesammenligningen er bare hypotetisk. For å gjøre kringkastingsoperasjoner som minne og beregningsøkonomisk som mulig, er Numpy smart nok til å bruke den opprinnelige skalarverdien i stedet for å produsere kopier.

Eksempel 2:

Her er et annet enkelt Python -program som utfører kringkasting. Nok en gang opprettes to matriser som inneholder forskjellige verdier. Det er nødvendig å omforme 'First_arr' til en kolonnevektor med en 3 × 1 form for å beregne et ytre produkt. Etter dette blir sendingen utført mot 'Second_arr' for å gi et resultat av størrelse 3 × 2, kjent som det ytre produktet fra 'First_arr' og 'Second_arr.'Kringkasting til 2 × 3 er mulig siden' Resultat_arr 'har formen 2 × 3 så vel som formen (3,).

Etter å ha fulgt alle de ovennevnte trinnene, må en vektor inkluderes i hver kolonne i matriser som er 'Resultat_arr' og 'Second_arr.'Disse har dimensjoner på 2 × 3 og (2,). Å transponere 'Resultat_arr' vil gi en form på 3 × 2, som deretter kan sendes mot 'Second_arr' for å få samme form. Typisk, å transponere dette gir et sluttprodukt i formen 2 × 3.

Importer numpy
first_arr = numpy.Array ([12, 24, 14])
Second_arr = numpy.Array ([15, 22])
trykk (Numpy.omform (first_arr, (3, 1)) * andre_arr)
resultat_arr = numpy.Array ([[12, 22, 31], [15, 22, 45]])
print (result_arr + first_arr)
trykk ((Resultat_arr.T + andre_arr).T)
trykk (resultat_arr + numpy.omforming (andre_arr, (2, 1)))
trykk (resultat_arr * 2)

Du kan se utdataene nedenfor.

Eksempel 3:

En tredimensjonal matrise kan sendes ved hjelp av følgende Python-program. I dette eksemplet har to matriser kalt 'First_arr' og 'Second_arr' blitt generert. Array 'First_arr' inneholder [4,13,26,12] verdier og 'Second_arr' inneholder [32,67,45,17] verdier. Den første matrisens 2-dimensjoner utgjør en forskjell. Den første og andre matrisens sum vises nedenfor etter at koden er utført. Du kan se at vi har tre utskriftserklæringer i koden, som hver viser teksten 'første matrise:', 'Second Array', og 'Third Array:' i sin tur. Summen av disse to ny genererte matriser vises deretter.

Importer numpy
first_arr = numpy.Array ([[4, 13, 26, 12], [32, 67, 45, 17]])
Second_arr = numpy.Array ([24,45,66,87])
trykk ("\ n første matrise:")
print (first_arr)
trykk ("\ n Second Array:")
print (andre_arr)
trykk ("\ nsum av første og andre matrise:")
sum_result = first_arr + second_arr;
print (sum_result)

Her er output -skjermbildet til den gitte koden.

Eksempel 4:

Det siste Python-programmet som sender en tredimensjonal matrise er gitt her. To matriser er spesifisert i dette programmet, hvorav den første har tre dimensjoner. Den første og andre matrisens sum vil bli vist som vist ovenfor etter at koden er utført. Selv om verdiene i disse matriser varierer, er den gjenværende koden den samme som brukt i eksempelprogrammet ovenfor.

Importer numpy
first_arr = numpy.Array ([[12, 45, 22, 13], [22, 54, 25, 12], [50, 40, 18, 26]])
Second_arr = numpy.Array ([12,44,22,12])
trykk ("\ n første matrise:")
print (first_arr)
trykk ("\ n Second Array:")
print (andre_arr)
trykk ("\ nsum av første og andre matrise:")
sum_result = first_arr + second_arr;
print (sum_result)

Du kan se på figuren nedenfor at en tredimensjonal matrise fra den første matrisen blir presentert, etterfulgt av en 2-dimensjonal matrise fra den andre matrisen og resultatet av disse to som bruker kringkastingsprinsippet.

Konklusjon

Denne artikkelen diskuterte kringkasting, et avgjørende Python -konsept. I Numpy refererer begrepet 'kringkasting' til kapasiteten til å håndtere matriser av forskjellige former mens du utfører aritmetiske operasjoner som ofte utføres. Det nevnte emnet er grundig dekket med en rekke eksempler. Denne artikkelen brukte de nevnte eksempelprogrammene for å demonstrere hvordan man sendes på henholdsvis 1-D, 2-D og 3-D-matriser. Du kan prøve å kjøre disse eksemplene på systemet ditt og se resultatene for å forstå hvordan alt fungerer generelt.