Numpy Broadcasting

Le array di dimensioni diverse non possono essere aggiunte, sottratte o altrimenti utilizzate in aritmetica. Duplicando l'array di piccoli per dargli le stesse dimensioni e dimensioni dell'array più grande è un approccio. Quando conducono aritmetica dell'array, Numpy offre una funzione nota come trasmissione di array che può ridurre e semplificare significativamente il codice. Imparerai sull'idea della trasmissione di array e come usarla in numpy in questo tutorial. Inoltre, vengono forniti diversi programmi di esempio.

Cos'è Numpy Broadcasting?

Quando si eseguono operazioni aritmetiche su matrici di diverse forme, Numpy si riferisce a questo come Broadcasting. Queste operazioni di array sono spesso eseguite sui rispettivi elementi. Se due array hanno la stessa forma, può essere fatto su di loro con facilità. Anche se questo concetto è utile, la trasmissione non è sempre raccomandata perché può comportare un utilizzo di memoria inefficiente che rallenta il calcolo. Le operazioni numpy vengono spesso eseguite su coppie di array che sono suddivise dall'elemento dall'elemento.

Regole di trasmissione

Una particolare serie di linee guida deve essere seguita durante la trasmissione. Questi sono descritti di seguito:

1. La forma dell'array di rango inferiore è importante da preparare con 1s fino a quando entrambe le forme degli array condividono la stessa lunghezza se due array non hanno lo stesso rango.
2. Due array sono considerati compatibili se hanno la stessa dimensione della dimensione o se una di esse ha la dimensione della dimensione impostata su 1.
3. Gli array possono essere trasmessi insieme solo se le loro dimensioni e dimensioni corrispondono.
4. Una volta completata la trasmissione, ogni array agisce come se la sua forma corrispondesse a quella dell'elemento più grande nelle forme dei due array di input.
5. Uno degli array si comporta come se fosse replicato con quella dimensione se l'altro array ha una dimensione maggiore di 1 e il primo array ha una dimensione di 1.

Ora, discutiamo alcuni esempi di implementazione del concetto di trasmissione.

Esempio 1:

Su coppie di array, le operazioni numpy vengono generalmente eseguite elementi per elementi. I due array devono, nello scenario più semplice, avere la stessa forma, come nell'esempio seguente:

importa numpy
one_arr = numpy.array ([2.0, 3.0, 1.0])
due_arr = numpy.array ([3.0, 3.0, 3.0])
stampa (one_arr * due_arr)

Come puoi vedere dal codice sopra, abbiamo due array: "one_arr" e "due_ arr". Ognuno dei quali ha un set separato di valori. I valori in "one_arr" sono [2.0,3.0,1.0] e 'due _arr' sono [3.0,3.0,3.0]. Puoi quindi vedere che il risultato del calcolo del prodotto di questi due array è il seguente:

Quando alcuni requisiti sono soddisfatti dalle forme degli array, la regola di trasmissione di Numpy abbassa questa restrizione. Quando un array e un valore scalare sono uniti in un'operazione, la trasmissione viene dimostrata nella sua forma più elementare. Come puoi vedere, 3 è contenuto nella variabile denominata 'due_arr.'

importa numpy
one_arr = numpy.array ([2.0, 3.0, 1.0])
due_arr = 3.0
stampa (one_arr * due_arr)

Il codice sopra produce il seguente risultato.

Nell'esempio precedente, in cui "due_arr" era un array, il risultato è equivalente. Possiamo immaginare che lo scalare "due_arr" venga espanso durante il processo aritmetico in un array con la stessa forma di "uno _arr."L'array" due_arr "contiene nuovi elementi che sono semplicemente duplicati del primo scalare. Il confronto di stretching è semplicemente ipotetico. Per rendere le operazioni di trasmissione come memoria e computazionalmente economiche come fattibili, Numpy è abbastanza intelligente da utilizzare il valore scalare originale piuttosto che produrre copie.

Esempio 2:

Ecco un altro semplice programma Python che esegue la trasmissione. Ancora una volta, vengono creati due array contenenti valori diversi. È necessario rimodellare "First_arr" in un vettore di colonna con una forma 3 × 1 per calcolare un prodotto esterno. In seguito, la trasmissione viene eseguita contro "Second_arr" per fornire un risultato della dimensione 3 × 2, noto come prodotto esterno di "First_arr" e "Second_arr.'La trasmissione a 2 × 3 è possibile poiché' Result_arr 'ha la forma 2 × 3 e la forma (3,).

Dopo aver seguito tutti i passaggi sopra menzionati, un vettore deve essere incluso in ogni colonna delle matrici che sono "result_arr" e "second_arr.'Questi hanno dimensioni di 2 × 3 e (2,). La trasposizione di 'Result_arr' produrrà una forma di 3 × 2, che può quindi essere trasmessa contro 'Second_arr' per ottenere la stessa forma. In genere, trasponendo questo produce un prodotto finale nella forma 2 × 3.

importa numpy
First_arr = numpy.Array ([12, 24, 14])
Second_arr = numpy.Array ([15, 22])
Stampa (numpy.Reshape (First_arr, (3, 1)) * Second_arr)
risultato_arr = numpy.Array ([[12, 22, 31], [15, 22, 45]])
Print (Result_arr + First_arr)
Stampa ((result_arr.T + second_arr).T)
Stampa (result_arr + Numpy.Reshape (second_arr, (2, 1)))
Print (Result_arr * 2)

È possibile visualizzare l'output di seguito.

Esempio 3:

Un array tridimensionale può essere trasmesso utilizzando il seguente programma Python. In questo esempio, sono stati generati due array denominati "First_arr" e "Second_arr". L'array 'First_arr' contiene [4,13,26,12] valori e 'Second_arr' contiene [32,67,45,17] valori. Le 2 dimensioni dell'array iniziale fanno la differenza. La somma del primo e del secondo array verrà mostrata di seguito dopo che il codice è stato eseguito. Puoi vedere che abbiamo tre istruzioni di stampa nel codice, ognuna delle quali visualizza il testo "primo array:", "secondo array" e "terzo array:" a sua volta. Viene quindi mostrata la somma di questi due matrici di nuova generazione.

importa numpy
First_arr = numpy.Array ([[4, 13, 26, 12], [32, 67, 45, 17]])
Second_arr = numpy.Array ([24,45,66,87])
print ("\ n primo array:")
Stampa (First_arr)
print ("\ n secondo array:")
Stampa (Second_arr)
print ("\ nsum del primo e secondo array:")
Sum_result = First_arr + Second_arr;
Stampa (sum_result)

Ecco lo screenshot di output del codice dato.

Esempio 4:

L'ultimo programma Python che trasmette un array tridimensionale è dato qui. In questo programma sono specificati due array, il primo delle quali ha tre dimensioni. La somma del primo e del secondo array verrà mostrata come mostrato sopra dopo che il codice è stato eseguito. Sebbene i valori in questi array variano, il codice rimanente è lo stesso di quello utilizzato nel programma di esempio sopra.

importa 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])
print ("\ n primo array:")
Stampa (First_arr)
print ("\ n secondo array:")
Stampa (Second_arr)
print ("\ nsum del primo e secondo array:")
Sum_result = First_arr + Second_arr;
Stampa (sum_result)

Si può vedere nella figura seguente che viene presentato un array tridimensionale dal primo array, seguito da un array bidimensionale dal secondo array e il risultato di questi due che impiegano il principio di trasmissione.

Conclusione

Questo articolo ha discusso di Broadcasting, un concetto cruciale di Python. In Numpy, il termine "trasmissione" si riferisce alla capacità di gestire array di varie forme mentre eseguono operazioni aritmetiche che vengono spesso eseguite. Il soggetto di cui sopra è stato accuratamente coperto da una varietà di esempi. Questo articolo ha utilizzato i programmi di esempio menzionati per dimostrare come trasmettere su array 1-D, 2-D e 3-D, rispettivamente. Puoi provare a eseguire questi esempi sul tuo sistema e visualizzare i risultati per comprendere meglio come tutto funziona in generale.