Wat is NumPy-uitzending?
Bij het uitvoeren van rekenkundige bewerkingen op arrays van verschillende vormen, noemt NumPy dit broadcasting. Deze array-bewerkingen worden vaak uitgevoerd op de respectieve elementen. Als twee arrays dezelfde vorm hebben, kan het er gemakkelijk op worden gedaan. Hoewel dit concept nuttig is, wordt broadcasting niet altijd aanbevolen, omdat dit kan leiden tot inefficiënt geheugengebruik dat de berekening vertraagt. NumPy-bewerkingen worden vaak uitgevoerd op arrayparen die element voor element worden opgesplitst.
Uitzendregels
Bij het uitzenden moet een bepaalde reeks richtlijnen worden gevolgd. Deze worden hieronder beschreven:
- De arrayvorm met een lagere rangorde is belangrijk om te worden voorafgegaan door enen totdat beide vormen van de arrays dezelfde lengte hebben als twee arrays niet dezelfde rangorde hebben.
- Twee arrays worden als compatibel beschouwd als ze dezelfde dimensiegrootte hebben of als een van hen de dimensiegrootte heeft ingesteld op 1.
- De arrays kunnen alleen samen worden uitgezonden als hun afmetingen en afmetingen overeenkomen.
- Zodra de uitzending is voltooid, gedraagt elke array zich alsof zijn vorm overeenkomt met die van het grootste element in de vorm van de twee invoerarrays.
- Een van de arrays gedraagt zich alsof deze is gerepliceerd met die dimensie als de andere array een dimensie groter dan 1 heeft en de eerste array een dimensie van 1 heeft.
Laten we nu enkele voorbeelden bespreken van het implementeren van het concept van omroep.
Voorbeeld 1:
Op paren van arrays worden NumPy-bewerkingen doorgaans element voor element uitgevoerd. De twee arrays moeten, in het meest eenvoudige scenario, dezelfde vorm hebben, zoals in het onderstaande voorbeeld:
importeren numpy
one_arr = numpig. reeks ( [ 2.0 , 3.0 , 1.0 ] )
two_arr = numpig. reeks ( [ 3.0 , 3.0 , 3.0 ] )
afdrukken ( een_arr * twee_arr )
Zoals je kunt zien aan de hand van de bovenstaande code, hebben we twee arrays: 'one_arr' en 'two_arr'. Die hebben elk een aparte set waarden. De waarden in 'one_arr' zijn [2.0,3.0,1.0] en 'two _arr' zijn [3.0,3.0,3.0]. U kunt dan zien dat het resultaat van het berekenen van het product van deze twee arrays als volgt is:
Wanneer aan bepaalde vereisten wordt voldaan door de formulieren van de arrays, verlaagt de uitzendregel van NumPy deze beperking. Wanneer een array en een scalaire waarde worden samengevoegd in een bewerking, wordt broadcasting in zijn meest elementaire vorm gedemonstreerd. Zoals je kunt zien, zit 3 in de variabele met de naam 'two_arr.'
importeren numpyone_arr = numpig. reeks ( [ 2.0 , 3.0 , 1.0 ] )
two_arr = 3.0
afdrukken ( een_arr * twee_arr )
De bovenstaande code levert het volgende resultaat op.
In het voorgaande voorbeeld, waar 'two_arr' een array was, is de uitkomst equivalent. We kunnen ons voorstellen dat de scalaire 'two_arr' tijdens het rekenproces wordt uitgebreid tot een array met dezelfde vorm als 'one _arr'. De array 'two_arr' bevat nieuwe elementen die slechts duplicaten zijn van de eerste scalaire waarde. De uitrekkende vergelijking is louter hypothetisch. Om uitzendingen zo geheugen en rekenkundig zo economisch mogelijk te maken, is NumPy slim genoeg om de originele scalaire waarde te gebruiken in plaats van kopieën te maken.
Voorbeeld 2:
Hier is nog een eenvoudig Python-programma dat uitzendingen uitvoert. Nogmaals, er worden twee arrays gemaakt met verschillende waarden. Het is noodzakelijk om 'first_arr' om te vormen tot een kolomvector met een 3×1-vorm om een buitenproduct te berekenen. Hierna wordt de uitzending uitgevoerd tegen 'second_arr' om een resultaat te krijgen van grootte 3×2, bekend als het buitenste product van 'first_arr' en 'second_arr'. Uitzenden naar 2×3 is mogelijk omdat 'result_arr' de vorm 2 heeft. ×3 en de vorm (3,).
Nadat alle bovengenoemde stappen zijn gevolgd, moet een vector worden opgenomen in elke kolom van de matrices die 'result_arr' en 'second_arr' zijn. Deze hebben afmetingen van 2×3 en (2, ). Het transponeren van 'result_arr' levert een vorm van 3 × 2 op, die vervolgens kan worden uitgezonden tegen 'second_arr' om dezelfde vorm te krijgen. Doorgaans levert het transponeren hiervan een eindproduct op in de vorm 2×3.
importeren numpyeerste_arr = numpig. reeks ( [ 12 , 24 , 14 ] )
second_arr = numpig. reeks ( [ vijftien , 22 ] )
afdrukken ( numpig. omvormen ( eerste_arr , ( 3 , 1 ) ) * second_arr )
resultaat_arr = numpig. reeks ( [ [ 12 , 22 , 31 ] , [ vijftien , 22 , Vier vijf ] ] )
afdrukken ( resultaat_arr + eerste_arr )
afdrukken ( ( resultaat_arr. T + second_arr ) . T )
afdrukken ( resultaat_arr + numpy. omvormen ( second_arr , ( twee , 1 ) ) )
afdrukken ( resultaat_arr * twee )
Hieronder kunt u de uitvoer bekijken.
Voorbeeld 3:
Een driedimensionale array kan worden uitgezonden met behulp van het volgende Python-programma. In dit voorbeeld zijn twee arrays met de naam 'first_arr' en 'second_arr' gegenereerd. De array 'first_arr' bevat [4,13,26,12] waarden en 'second_arr' bevat [32,67,45,17] waarden. De 2-dimensies van de initiële array maken een verschil. De som van de eerste en tweede array wordt hieronder weergegeven nadat de code is uitgevoerd. Je kunt zien dat we drie print-statements in de code hebben, die elk de tekst 'First array:', 'Second array' en 'Third array:' om de beurt weergeven. De som van deze twee nieuw gegenereerde arrays wordt dan getoond.
importeren numpyeerste_arr = numpig. reeks ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , Vier vijf , 17 ] ] )
second_arr = numpig. reeks ( [ 24 , Vier vijf , 66 , 87 ] )
afdrukken ( ' \n Eerste reeks: ' )
afdrukken ( eerste_arr )
afdrukken ( ' \n Tweede reeks: ' )
afdrukken ( second_arr )
afdrukken ( ' \n Som van eerste en tweede array: ' )
sum_result = eerste_arr + tweede_arr ;
afdrukken ( sum_result )
Hier is de output-screenshot van de gegeven code.
Voorbeeld 4:
Het laatste Python-programma dat een driedimensionale array uitzendt, wordt hier gegeven. In dit programma worden twee arrays gespecificeerd, waarvan de eerste drie dimensies heeft. De som van de eerste en tweede array wordt weergegeven zoals hierboven weergegeven nadat de code is uitgevoerd. Hoewel de waarden in deze arrays variëren, is de resterende code dezelfde als die in het bovenstaande voorbeeldprogramma.
importeren numpyeerste_arr = numpig. reeks ( [ [ 12 , Vier vijf , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ vijftig , 40 , 18 , 26 ] ] )
second_arr = numpig. reeks ( [ 12 , 44 , 22 , 12 ] )
afdrukken ( ' \n Eerste reeks: ' )
afdrukken ( eerste_arr )
afdrukken ( ' \n Tweede reeks: ' )
afdrukken ( second_arr )
afdrukken ( ' \n Som van eerste en tweede array: ' )
sum_result = eerste_arr + tweede_arr ;
afdrukken ( sum_result )
Je kunt in de onderstaande afbeelding zien dat een driedimensionale array uit de eerste array wordt gepresenteerd, gevolgd door een tweedimensionale array uit de tweede array en het resultaat van deze twee met behulp van het uitzendprincipe.
Conclusie
Dit artikel besprak broadcasting, een cruciaal Python-concept. In NumPy verwijst de term 'uitzenden' naar het vermogen om arrays van verschillende vormen te verwerken tijdens het uitvoeren van rekenkundige bewerkingen die vaak worden uitgevoerd. Het bovengenoemde onderwerp is uitgebreid behandeld met een verscheidenheid aan voorbeelden. In dit artikel worden de genoemde voorbeeldprogramma's gebruikt om te demonstreren hoe u kunt uitzenden op respectievelijk 1-D-, 2-D- en 3D-arrays. U kunt proberen deze voorbeelden op uw systeem uit te voeren en de resultaten bekijken om beter te begrijpen hoe alles in het algemeen werkt.