Broadcast do NumPy

O broadcast do NumPy é principalmente aplicado durante operações aritméticas para lidar com arrays de diferentes formas. Sob certas restrições, o array menor "broadcast" no array maior para que eles tenham formas compatíveis.
Operações do NumPy são geralmente realizadas em pares de arrays, elemento a elemento. No caso mais simples, dois arrays devem ter formas completamente iguais, conforme exemplo a seguir:

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

ao calcular 2 quando os tamanhos de diferentes arrays são diferentes, o numpy aciona automaticamente o mecanismo de broadcast. Por exemplo:

　>>> import numpy as np
　>>> a = np.array([
　　　　　　　　　　　　[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]]

a seguir, a imagem mostra como o array b se compatibiliza com o array a através do broadcast.

4x3 um array bidimensional com comprimento 3 soma de arrays unidimensionais é equivalente a repetir o array b em duas dimensões 4 reoperação:

　>>> import numpy as np
　>>> a = np.array([
　　　　　　　　　　　　[10,10,10],
　　　　　　　　　　　　[20,20,20],
　　　　　　　　　　　　[30,30,30]])
　>>> b = np.array([1,2,3))
　>>> bb = np.tile(b, (4,　1)) # Repetir cada dimensão do b
　>>> print(a　+　bb)
　[[　1　2　3]]
　　[11　12　13]]
　　[21　22　23]]
　　[31　32　33]]

regras de broadcast gerais

ao executar em dois arrays, o NumPy compara suas formas elemento a elemento. Ele começa pela dimensão mais ao final e vai para a frente. As dimensões são compatíveis quando

eles são iguais ou
um deles é1

Se essas condições não forem atendidas, será lançada a exceção ValueError: operands could not be broadcast together, indicando que os arrays têm formas incompatíveis. O tamanho do array resultante é ao longo de cada eixo de entrada não1tamanho.

o array não precisa ter o mesmo número de dimensões. Por exemplo, se você tiver256x256x3um array de valores RGB e deseja escalar cada cor do imagem para diferentes valores, pode-se multiplicar a imagem por um array com3um array unidimensional de um valor. A disposição destes arrays de acordo com as regras de broadcast indica que eles são compatíveis:

　Image (3d (array):　256　x　256　x　3
　Scale (1d (array):　3
　Result (3d (array):　256　x　256　x　3

quando qualquer um dos tamanhos comparados for1ao usar outro tamanho. Em outras palavras, o tamanho1o tamanho é esticado ou "copia" para coincidir com outro tamanho. No seguinte exemplo, os arrays A e B têm comprimento1eixo, durante a operação broadcast, se expande para um tamanho maior:

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

A seguir estão alguns exemplos:

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

A seguir está um exemplo de forma não broadcast:

　A (1d (array):　3
　B (1d (array):　4　#trailing dimensions do not match
　A (2d (array):　2　x　1
　B (3d (array):　8　x　4　x　3　#última dimensão não coincide

Um exemplo prático de 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: os operandos não puderam ser broadcast juntos com formas (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.]])

Broadcast oferece um método conveniente para obter o exergue externo (ou qualquer outra operação externa) de dois arrays. O exemplo a seguir mostra dois1-Operação de exergue externa do array 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.]])

Aqui newaxisOperador de índice inserido uma nova eixo a para torná-lo bidimensional 4x1Array. Coloque 4x1Array e forma (3,)do bCombinação, para gerar um 4x3Array.