Operazioni bitwise NumPy

Il broadcast NumPy viene principalmente applicato durante le operazioni aritmetiche per gestire array con forme diverse. Sotto l'influenza di alcune restrizioni, l'array più piccolo viene 'broadcast' sull'array più grande in modo che abbiano forme compatibili.
Le operazioni NumPy vengono eseguite element per element sugli array. Nel caso più semplice, due array devono avere forme completamente identiche, come nell'esempio seguente:

　>>> import numpy as np
　>>> a = np.array([1, 2, 3])
　>>> b = np.array([2, 2, 2])
　>>> a * b
　array([ 2, 4, 6])

Quando i due array in un'operazione hanno forme diverse, NumPy attiva automaticamente il meccanismo di broadcast. Ad esempio:

　>>> import numpy as np
　>>> a = np.array([[ 0, 0, 0],
　　　　　　　　　　　　[10,10,10],
　　　　　　　　　　　　[20,20,20],
　　　　　　　　　　　　[30,30,30]])
　>>> b = np.array([1,2,3])
　>>> print(a + b)
　[[ 1 2 3]
　　[11 12 13]
　　[21 22 23]
　　[31 32 33]]

L'immagine seguente mostra come l'array b si broadcast per diventare compatibile con l'array a.

Un array bidimensionale 4x3 sommato a un array mono-dimensionale di lunghezza 3 è equivalente a moltiplicare l'array b 4 volte in due dimensioni e poi eseguire l'operazione:

　>>> import numpy as np
　>>> a = np.array([[ 0, 0, 0],
　　　　　　　　　　　　[10,10,10],
　　　　　　　　　　　　[20,20,20],
　　　　　　　　　　　　[30,30,30]])
　>>> b = np.array([1,2,3])
　>>> bb = np.tile(b, (4, 1))  # Ripeti b per ciascuna dimensione
　>>> print(a + bb)
　[[ 1 2 3]
　　[11 12 13]
　　[21 22 23]
　　[31 32 33]]

Regole generali di broadcast

Quando eseguiti in due array, NumPy li confronta elemento per elemento. Partendo dall'asse finale, procede verso l'avanzo. Due dimensioni sono compatibili quando

Sono uguali o
Una di queste è 1

Se non si soddisfano queste condizioni, viene lanciata l'eccezione ValueError: operands could not be broadcast together, che indica che gli array hanno forme incompatibili. La dimensione dell'array di risultato è diversa da 1 lungo ogni asse di input.

L'array non deve avere dimensioni identiche. Ad esempio, se hai un array a valori RGB 256x256x3 e desideri scalare i valori di ciascun colore in modo diverso, puoi moltiplicare l'immagine per un array mono-dimensionale con tre valori. Secondo le regole di broadcast, la dimensione dell'asse finale di questi array indica che sono compatibili:

　Immagine (array 3d): 256 x 256 x 3
　Scala (array 1d): 3
　Risultato (array 3d): 256 x 256 x 3

Quando uno qualsiasi delle dimensioni di confronto è 1, utilizzare l'altra dimensione. In altre parole, la dimensione 1 viene estesa o "copiata" per corrispondere all'altra dimensione. Nei seguenti esempi, gli array A e B hanno un asse di lunghezza 1, che viene espanso durante l'operazione di broadcast a una dimensione più grande:

　A (array 4d): 8 x 1 x 6 x 1
　B (array 3d): 7 x 1 x 5
　Risultato (array 4d): 8 x 7 x 6 x 5

Esempi di seguito:

　A (array 2d): 5 x 4
　B (array 1d): 1
　Risultato (array 2d): 5 x 4
　A (array 2d): 5 x 4
　B (array 1d): 4
　Risultato (array 2d): 5 x 4
　A (array 3d): 15 x 3 x 5
　B (array 3d): 15 x 1 x 5
　Risultato (array 3d): 15 x 3 x 5
　A (array 3d): 15 x 3 x 5
　B (array 2d): 3 x 5
　Risultato (array 3d): 15 x 3 x 5
　A (array 3d): 15 x 3 x 5
　B (array 2d): 3 x 1
　Risultato (array 3d): 15 x 3 x 5

Esempio di forme non diffuse:

　A (array 1d): 3
　B (array 1d): 4 # La dimensione finale non corrisponde
　A (array 2d): 2 x 1
　B (array 3d): 8 x 4 x 3 # La dimensione penultima non corrisponde

Esempio pratico di broadcast:

　>>> import numpy as np
　>>> x = np.arange(4)
　>>> xx = x.reshape(4, 1)
　>>> y = np.ones(5)
　>>> z = np.ones((3, 4))
　>>> x.shape
　(4,)
　>>> y.shape
　(5,)
　>>> x + y
　ValueError: gli operandi non possono essere diffusi insieme con le forme (4,) (5,)
　>>> xx.shape
　(4, 1)
　>>> y.shape
　(5,)
　>>> (xx + y).shape
　(4, 5)
　>>> xx + y
　array([[1., 1., 1., 1., 1.],
　　　　　　　　[　2.,　2.,　2.,　2.,　2.]
　　　　　　　　[　3.,　3.,　3.,　3.,　3.],
　　　　　　　　[　4.,　4.,　4.,　4.,　4.]]
　>>> x.shape
　(4,)
　>>> z.shape
　(3,　4)
　>>> (x　+　z).shape
　(3,　4)
　>>> x　+　z
　array([[　1.,　2.,　3.,　4.],
　　　　　　　　>>> [　1.,　2.,　3.,　4.],
　　　　　　　　>>> [　1.,　2.,　3.,　4.]]

Il broadcasting fornisce un modo comodo per ottenere il prodotto esterno (o qualsiasi altra operazione esterna) di due array. Ecco un esempio di operazione di prodotto esterno su due array 1-d:

　>>> import numpy as np
　>>> a　=　np.array([0.0,　10.0,　20.0,　30.0])
　>>> b　=　np.array([1.0,　2.0,　3.0])
　>>> a[:,　np.newaxis]　+　b
　array([[　1.,　2.,　3.],
　　　　　　　　[　11.,　12.,　13.],
　　　　　　　　[　21.,　22.,　23.],
　　　　　　　　[　31.,　32.,　33.]])

qui newaxisOperatore di indice per inserire un nuovo asse a per renderlo 4x1Array. Porta 4x1Array con forma (3,)del bCombinazione, che produce un 4x3Array.