Comment utiliser la fonction numpy.ufunc en Python

1. Explication

                                                                     Quelle fonction est numpy.ufunc ? Réponse : Il s'agit d'une fonction numpy, car numpy cible les tenseurs de tableau, donc presque toutes les fonctions sont des ufunc. Oui 2. Concept de fonction Numpy.ufunc

2.1 Profil numpy.ufunc

La fonction opérée par des éléments sur l'ensemble du tableau. Par conséquent, ufunc est un terme général et il existe plusieurs de ces fonctions. ?                                              Une fonction universelle (ou ufunc en abrégé) est une fonction qui fonctionne sur les ndarrays élément par élément, prenant en charge la diffusion de tableaux, la conversion de type et certaines autres fonctionnalités standard. Ufunc est un wrapper qui « vectorise » une fonction, prenant un nombre fixe d'entrées spécifiques et produisant un nombre fixe de sorties spécifiques. Voir les détails de la fonction universelle sous-jacente (ufunc).

Dans NumPy, les fonctions générales sont des instances de la classe numpy.ufunc. De nombreuses fonctions intégrées sont implémentées dans le code C compilé. Les ufuncs de base fonctionnent sur des scalaires, mais il existe également un type générique où les éléments de base sont des sous-tableaux (vecteurs, matrices, etc.) et la diffusion se fait dans d'autres dimensions. Vous pouvez également ufunc utiliser la fonction frompyfuncopen dans une nouvelle usine de fenêtre pour générer une instance personnalisée.

2.2 numpy.ufunc.nin et numpy.ufunc.nout

Cette fonction exprime le nombre de paramètres d'entrée correspondant à la fonction ufun, comme indiqué ci-dessous. numpy.ufunc类的实例 。 许多内置函数都是在编译的C代码中实现的。 基本的ufuncs对标量进行操作，但也有一种通用类型，基本元素是子数组（向量，矩阵等）， 广播是在其他维度上完成的。也可以ufunc使用frompyfuncopen in new window工厂函数生成自定义实例。

2.2 numpy.ufunc.nin和numpy.ufunc.nout

        该函数表述出对应ufun函数的输入参数数量，如下列ufunc时对应的输入参数个数。

np.add.nin
2
np.multiply.nin
2
np.power.nin
2
np.exp.nin
2

该函数表述出对应ufun函数的输出参数数量，如下列ufunc时对应的输入参数个数。

np.add.nout
1
np.multiply.nout
1
np.power.nout
1
np.exp.nout
1

2.3 numpy.ufunc.nargs

numpy.ufunc对应参数的个数，

np.add.nargs
3
np.multiply.nargs
3
np.power.nargs
3
np.exp.nargs
2

如np.add函数有三个参数，两个输入，一个输出，如下：

a = np.array([2,4,5,6])
b = np.array([2,2,3,3])
c = np.zeros((4,))
np.add(  a,b,c )
print( c )

2.4 numpy.ufunc.ntypes

表明一个ufunc的输入数据类型格式：ufunc 可以操作的数字 NumPy 类型的数量——总共有 18 种。

np.add.ntypes
18
np.multiply.ntypes
18
np.power.ntypes
17
np.exp.ntypes
7
np.remainder.ntypes
14

2.5 numpy.ufunc.type

np.add.types
['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
'GG->G', 'OO->O']
np.multiply.types
['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
'GG->G', 'OO->O']
np.power.types
['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G',
'OO->O']
np.exp.types
['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O']
np.remainder.types
['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O']

2.6 维度ndim和shape

表明维度的参数有两个，array.ndim 和 array.shape,其中ndim是指张量共几个维度，shape是指每个维度下的向量长度。比如下例：

x = np.array([1, 2, 3])
print(x.ndim)
print(x.shape)
 
y = np.zeros((2, 3, 4))
print(y.ndim)
print(y.shape)

结果：

1
(3,)
3
(2, 3, 4)

三、ufunc的广播特性

每个通函数接受数组输入并通过在输入上逐元素地执行核心功能来生成数组输出（其中元素通常是标量，但可以是用于广义ufunc的向量或更高阶子数组）。按照标准广播规则进行操作，以确保即使输入不具有完全相同的形状，仍能有效进行操作。 广播可以通过四个规则来理解：

1. 所有输入数组都ndimopen in new window小于最大的输入数组，ndimopen in new window其形状前面有1个。

2. 输出形状的每个维度的大小是该维度中所有输入大小的最大值。

3. 如果输入在特定维度中的大小与该维度中的输出大小匹配，或者其值正好为1，则可以在计算中使用该输入。

4. 当形状尺寸为1时，该维度中的第一个数据条目将被用于所有沿该维度的计算。换句话说，ufuncopen in new window的步进机械 将不会沿着该维度步进（对于该维度，步幅将为0）。

整个NumPy使用广播来决定如何处理不同形状的数组; 例如，所有算术运算（+， -，*之间，...）ndarraysopen in new window的数组操作之前广播。

如果上述规则产生有效结果，则将一组数组称为“可广播”到相同的形状， 即 满足下列条件之一：

• 数组都具有完全相同的形状。

• 数组都具有相同的维数，每个维度的长度是公共长度或1。

• 尺寸太小的数组可以使其形状前置为长度为1的尺寸以满足属性2。

如果a.shape是 (5,1)，b.shape是 (1,6)，c.shape是 (6，)并且d.shape

a = np.array([2,4,5,6])
b = np.array([2,2,3,3])
c = np.zeros((4,))
np.add(  a,b,c )
print( c )

Cette fonction exprime le nombre de paramètres de sortie correspondant à la fonction ufun, comme le nombre correspondant de paramètres d'entrée pour l'ufunc suivant.

a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
 
print(a)
print(b)

• 2.3 numpy.ufunc.nargs
  numpy.ufunc correspond au nombre de paramètres,

a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
 
print(a)
print(b)
 
s = a + b
print(s)

• Par exemple, la fonction np.add a trois paramètres, deux entrées et une sortie, comme suit :

  np.add.accumulate([2, 3, 5])
  array([ 2,  5, 10])
  np.multiply.accumulate([2, 3, 5])
  array([ 2,  6, 30])

  2.4 numpy "                        Indique le format du type de données d'entrée d'un ufunc : le nombre de types numériques NumPy que l'ufunc peut exploiter - 18 au total. 🎜

  np.add.accumulate(I, 0)
  array([[1.,  0.],
         [1.,  1.]])
  np.add.accumulate(I) # no axis specified = axis zero
  array([[1.,  0.],
         [1.,  1.]])

  🎜 2.5 numpy.ufunc.type🎜

  a = np.array([1, 2, 3, 4])
  np.negative.at(a, [0, 1])
  print( a )
  array([-1, -2,  3,  4])

  🎜2.6 Dimension ndim et shape🎜🎜 Il existe deux paramètres indiquant la dimension, array.ndim et array.shape, où ndim fait référence au nombre total de dimensions du tenseur et à la forme fait référence à chaque dimension. La longueur du vecteur en dimensions. Par exemple, l'exemple suivant : 🎜

  a = np.array([1, 2, 3, 4])
  np.add.at(a, [0, 1, 2, 2], 1)
  print( a )
  array([2, 3, 5, 4])

  🎜 Résultat : 🎜

  🎜1
  (3,)
  3
  (2, 3, 4)🎜

  🎜3. Diffusion des fonctionnalités d'ufunc 函 Chaque fonction générale accepte l'entrée du tableau et génère une sortie du tableau en exécutant la fonction principale sur l'entrée (où l'élément est généralement un scalaire, mais il peut s'agir d'un vecteur ou d'un sous-tableau supérieur pour un UFUNC plus large). Suivez les règles de diffusion standard pour garantir que même si les entrées n'ont pas exactement la même forme, l'opération fonctionnera toujours efficacement. La diffusion peut être comprise par quatre règles : 🎜
  🎜🎜Tous les tableaux d'entrée sont plus petits que le plus grand tableau d'entrée, ndimopen in new window dont la forme est précédée de 1. 🎜🎜🎜🎜La taille de chaque dimension de la forme de sortie est le maximum de toutes les tailles d'entrée dans cette dimension. 🎜🎜🎜🎜Si la taille de l'entrée dans une dimension spécifique correspond à la taille de la sortie dans cette dimension, ou si sa valeur est exactement 1, alors l'entrée peut être utilisée dans le calcul. 🎜🎜🎜🎜Lorsque la dimension de la forme est 1, la première saisie de données dans cette dimension sera utilisée pour tous les calculs le long de cette dimension. En d'autres termes, la machine pas à pas de ufuncopen dans une nouvelle fenêtre ne suivra pas cette dimension (la foulée sera de 0 pour cette dimension). 🎜🎜
  🎜 La diffusion est utilisée dans NumPy pour décider comment gérer les tableaux de différentes formes ; par exemple, toutes les opérations arithmétiques (+, -, *</ code>, ...) Les ndarrays sont diffusés avant les opérations sur les tableaux dans une nouvelle fenêtre. 🎜🎜          Un ensemble de tableaux est dit "diffusable" sous la même forme si les règles ci-dessus produisent des résultats valides, c'est-à-dire que l'une des conditions suivantes est remplie : 🎜🎜🎜🎜Les tableaux ont tous exactement la même forme. 🎜🎜🎜🎜Les tableaux ont tous le même nombre de dimensions, et la longueur de chaque dimension est la longueur commune ou 1. 🎜🎜🎜🎜Un tableau avec des dimensions trop petites peut avoir sa forme ajoutée à une dimension de longueur 1 pour satisfaire l'attribut 2. 🎜🎜</ul>🎜 Si <code>a.shape est (5,1), b.shape est (1,6), c.shape</ code> code> est (6,) et <code>d.shape est () tel que d est un scalaire, alors a , b , c et d peuvent tous être diffusés aux dimensions (5, 6) ; et : 🎜🎜🎜 🎜a agit comme un tableau (5,6), où [:, 0] diffuse vers d'autres colonnes, 🎜🎜🎜🎜b agit comme un tableau (5,6), où b[0, :] diffusions vers d'autres colonnes OK, 🎜

• c被视为类似于一个(1,6)的矩阵，因此类似于一个(5,6)的矩阵，其中c的每一项元素被广播到每一行，最终，...

• d 的作用类似于（5,6）数组，其中重复单个值。

四、函数格式

可以在通用函数 (ufunc) 的文档中找到有关 ufunc 的详细说明。

调用ufuncs格式:

op( *x[, out], where=True, **kwargs)

将 op 应用于参数 *x elementwise，广播参数。

广播规则是：

长度为 1 的维度可以添加到任一数组之前。

数组可以沿长度为 1 的维度重复。

参数：

*xarray_like

outndarray，None，或 ndarray 和 None 的元组，可选

用于放置结果的备用数组对象；如果提供，它必须具有输入广播的形状。数组元组（可能仅作为关键字参数）的长度必须等于输出的数量；对 ufunc 分配的未初始化输出使用 None。

wherearray_like，可选

此条件通过输入广播。当条件为 True 时，ufunc 的结果将被赋值给 out 数组。在其他地方，out 数组将保留其原始值。请注意，如果通过默认 out=None 创建未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化状态。

五、示例详解

5.1 用输出参数

a = np.array([2,4,5,6])
b = np.array([2,2,3,3])
c = np.zeros((4,))
np.add(  a,b,c )
print( c )

5.2 行数组和列数组

a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
 
print(a)
print(b)

输出：

[0 1 2]
[[0]
[1]
[2]]

5.3 广播规则示例

a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
 
print(a)
print(b)
 
s = a + b
print(s)

六、ufunc后的数列运算

6.1 数列运算

在执行ufunc运算后，常常伴随数列运算，它们如下

__call__(*args, **kwargs)	Call self as a function.
accumulate(array[, axis, dtype, out])	Accumulate the result of applying the operator to all elements.
at(a, indices[, b])	Performs unbuffered in place operation on operand 'a' for elements specified by 'indices'.
outer(A, B, /, **kwargs)	Apply the ufunc op to all pairs (a, b) with a in A and b in B.
reduce(array[, axis, dtype, out, keepdims, ...])	Reduces array's dimension by one, by applying ufunc along one axis.
reduceat(array, indices[, axis, dtype, out])	Performs a (local) reduce with specified slices over a single axis.
resolve_dtypes(dtypes, *[, signature, ...])	Find the dtypes NumPy will use for the operation.

6.2 累计模式

累计模式不可以单独使用，而是与add以及multiply搭配使用：

np.add.accumulate([2, 3, 5])
array([ 2,  5, 10])
np.multiply.accumulate([2, 3, 5])
array([ 2,  6, 30])

np.add.accumulate(I, 0)
array([[1.,  0.],
       [1.,  1.]])
np.add.accumulate(I) # no axis specified = axis zero
array([[1.,  0.],
       [1.,  1.]])

6.3 对数组中某个index的元素进行局部处理

1) 将项目 0 和 1 设置为负值：

a = np.array([1, 2, 3, 4])
np.negative.at(a, [0, 1])
print( a )
array([-1, -2,  3,  4])

2) 递增项目 0 和 1，递增项目 2 两次：

a = np.array([1, 2, 3, 4])
np.add.at(a, [0, 1, 2, 2], 1)
print( a )
array([2, 3, 5, 4])

3) 将第一个数组中的项 0 和 1 添加到第二个数组，并将结果存储在第一个数组中：

a = np.array([1, 2, 3, 4])
b = np.array([1, 2])
np.add.at(a, [0, 1], b)
print(a)
array([2, 4, 3, 4])

6.4 outer外积

简单数组外积

np.multiply.outer([1, 2, 3], [4, 5, 6])
array([[ 4,  5,  6],
       [ 8, 10, 12],
       [12, 15, 18]])

张量的外积

A = np.array([[1, 2, 3], [4, 5, 6]])
A.shape
(2, 3)
B = np.array([[1, 2, 3, 4]])
B.shape
(1, 4)
C = np.multiply.outer(A, B)
C.shape; C
(2, 3, 1, 4)
array([[[[ 1,  2,  3,  4]],
        [[ 2,  4,  6,  8]],
        [[ 3,  6,  9, 12]]],
       [[[ 4,  8, 12, 16]],
        [[ 5, 10, 15, 20]],
        [[ 6, 12, 18, 24]]]])

6.5 reduce方法

a = np.multiply.reduce([2,3,5])
print( a)
30

X = np.arange(8).reshape((2,2,2))
X
array([[[0, 1],
        [2, 3]],
       [[4, 5],
        [6, 7]]])
np.add.reduce(X, 0)
array([[ 4,  6],
       [ 8, 10]])
np.add.reduce(X) # confirm: default axis value is 0
array([[ 4,  6],
       [ 8, 10]])
np.add.reduce(X, 1)
array([[ 2,  4],
       [10, 12]])
np.add.reduce(X, 2)
array([[ 1,  5],
       [ 9, 13]])

您可以使用 initial 关键字参数以不同的值初始化缩减，以及在何处选择要包含的特定元素：

np.add.reduce([10], initial=5)
15
np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10)
array([14., 14.])
a = np.array([10., np.nan, 10])
np.add.reduce(a, where=~np.isnan(a))
20.0

np.minimum.reduce([], initial=np.inf)
inf
np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False])
array([ 1., 10.])
np.minimum.reduce([])
Traceback (most recent call last):

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!