NumPy 位运算

Le broadcast NumPy est principalement utilisé pour traiter des arrays de formes différentes pendant les opérations arithmétiques. Soumis à certaines contraintes, les arrays plus petits sont «broadcastés» sur les arrays plus grands afin qu'ils aient des formes compatibles.
Les opérations NumPy sont généralement effectuées élément par élément sur les paires d'arrays. Dans le cas le plus simple, deux arrays doivent avoir la même forme, comme dans l'exemple suivant :

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

Lorsque l'opérateur 2 Quand le nombre de formes des tableaux est différent, numpy déclenche automatiquement le mécanisme de broadcast. Par exemple :

　>>> 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'image suivante montre comment le tableau b peut être broadcast pour correspondre au tableau a.

4x3 un tableau bidimensionnel de longueur 3 l'addition d'un tableau unidimensionnel est équivalent à la répétition bidimensionnelle du tableau b 4 Opérations de recalcul :

　>>> 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))　#　répéter　les dimensions de b
　>>> print(a　+　bb)
　[[　1　2　3]]
　　[11　12　13]]
　　[21　22　23]]
　　[31　32　33]]

Les règles de broadcast générales

Lorsque les deux tableaux sont exécutés, NumPy compare leurs formes élément par élément. Il commence par la dimension la plus en arrière et progresse vers l'avant. Les dimensions sont compatibles lorsque

ils sont égaux, ou
l'un des deux1

Si ces conditions ne sont pas remplies, une exception ValueError: operands could not be broadcast together est levée, indiquant que les tableaux ont des formes incompatibles. La taille du tableau de résultat est le long de chaque axe d'entrée et non1de taille.

Les tableaux n'ont pas besoin d'avoir le même nombre de dimensions. Par exemple, si vous avez256x256x3un tableau d'arrays de valeurs RGB, et vous souhaitez que chaque couleur de l'image soit élastique à une valeur différente, vous pouvez multiplier l'image par un tableau avec3Les tailles des dernières dimensions de ces tableaux sont排列 en fonction des règles de broadcast pour indiquer qu'ils sont compatibles :

　Un tableau unidimensionnel contenant3d　array):　256　x　256　x　3
　Image　(1d　array):　3
　Result　(3d　array):　256　x　256　x　3

Scale　(1lorsque l'une des tailles comparées est1La taille est étirée ou «copiée» pour correspondre à une autre taille. Dans l'exemple suivant, les tableaux A et B ont tous deux une longueur de1l'axe, qui s'étend à une plus grande taille pendant l'opération de broadcast :

　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

Voici quelques exemples :

　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

Voici des exemples de formes non propagées :

　A　(1d　array):　3
　B　(1d　array):　4　#La dernière dimension ne correspond pas
　A　(2d　array):　2　x　1
　B　(3d　array):　8　x　4　x　3　#La dernière dimension ne correspond pas

实践中广播的一个实例：

　>>> 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: operands could not be broadcast together with shapes (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.]])

广播提供了一种方便的方式来获取两个数组的外积（或任何其他外部操作）。以下示例显示了两个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.]])

这里 newaxis索引操作符插入一个新轴 a ，使其成为一个二维 4x1数组。将 4x1数组与形状为 (3,)的 b组合，产生一个 4x3数组。