Broadcasting NumPy

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

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

Quando due array hanno forme diverse nell'operazione, 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 essere compatibile con l'array a.

Un array bidimensionale 4x3 sommato a un array uno-dimensionale di lunghezza 3 è equivalente a moltiplicare l'array b 4 volte in due dimensioni prima di 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 tutte le dimensioni
　>>> print(a + bb)
　[[ 1 2 3]
　　[11 12 13]
　　[21 22 23]
　　[31 32 33]]

Regole di broadcast generali

Quando si eseguono operazioni su due array, NumPy li confronta elemento per elemento. Comincia dalla dimensione più estrema e procede verso l'interno. 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 uguali. 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 uno-dimensionale con 3 valori. Secondo le regole di broadcast, l'ordine delle dimensioni alla fine degli 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 allungata o "copiata" per corrispondere all'altra dimensione. Nei seguenti esempi, gli array A e B hanno un asse di lunghezza 1, che si espande a una dimensione più grande durante l'operazione di broadcast:

　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 # Le dimensioni finali non corrispondono
　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 di 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.]])

Ecco newaxisOperatore di indici per inserire un nuovo asse a per renderlo un array 4x1Array. Portare 4x1Array con forma (3,)del bCombinazione, generando un 4x3Array.