numpy max vs amax vs maximum

numpy a trois fonctions différentes qui semblent pouvoir être utilisées pour les mêmes choses - sauf qu'elles numpy.maximumne peuvent être utilisées que par élément, tandis que numpy.maxet numpy.amaxpeuvent être utilisées sur des axes particuliers, ou sur tous les éléments. Pourquoi y a-t-il plus que juste numpy.max? Y a-t-il une certaine subtilité dans la performance?

(De même pour minvs. aminvs. minimum)

np.maxest juste un alias pour np.amax. Cette fonction ne fonctionne que sur un seul tableau d'entrée et trouve la valeur de l'élément maximum dans tout ce tableau (renvoyant un scalaire). Sinon, il prend un axisargument et trouvera la valeur maximale le long d'un axe du tableau d'entrée (retournant un nouveau tableau).

>>> a = np.array([[0, 1, 6],
                  [2, 4, 1]])
>>> np.max(a)
6
>>> np.max(a, axis=0) # max of each column
array([2, 4, 6])

Le comportement par défaut de np.maximumest de prendre deux tableaux et de calculer leur maximum élément par élément. Ici, «compatible» signifie qu'un tableau peut être diffusé vers l'autre. Par exemple:

>>> b = np.array([3, 6, 1])
>>> c = np.array([4, 2, 9])
>>> np.maximum(b, c)
array([4, 6, 9])

Mais np.maximumc'est aussi une fonction universelle, ce qui signifie qu'elle possède d'autres fonctionnalités et méthodes utiles lorsque vous travaillez avec des tableaux multidimensionnels. Par exemple, vous pouvez calculer le maximum cumulé sur un tableau (ou un axe particulier du tableau):

>>> d = np.array([2, 0, 3, -4, -2, 7, 9])
>>> np.maximum.accumulate(d)
array([2, 2, 3, 3, 3, 7, 9])

Ce n'est pas possible avec np.max.

Vous pouvez faire np.maximumimiter np.maxdans une certaine mesure lors de l'utilisation np.maximum.reduce:

>>> np.maximum.reduce(d)
9
>>> np.max(d)
9

Les tests de base suggèrent que les deux approches sont comparables en termes de performances; et ils devraient l'être, comme les np.max()appels en faitnp.maximum.reduce pour faire le calcul.

Vous avez déjà expliqué pourquoi np.maximumest différent - il renvoie un tableau qui est le maximum élément par élément entre deux tableaux.

Quant à np.amaxet np.max: ils appellent tous les deux la même fonction - np.maxn'est qu'un alias pour np.amax, et ils calculent le maximum de tous les éléments d'un tableau, ou le long d'un axe d'un tableau.

In [1]: import numpy as np

In [2]: np.amax
Out[2]: <function numpy.core.fromnumeric.amax>

In [3]: np.max
Out[3]: <function numpy.core.fromnumeric.amax>

Par souci d'exhaustivité, dans Numpy, il existe quatre fonctions liées au maximum . Ils appartiennent à deux catégories différentes:

• np.amax/np.max, np.nanmax: pour les statistiques d'ordre d'un seul tableau
• et np.maximum, np.fmax: à titre de comparaison élément par élément des deux tableaux

I. Pour les statistiques d'ordre d'un seul tableau

Propagateur NaNs np.amax/np.maxet son homologue ignorant NaN np.nanmax.

• np.maxest juste un alias de np.amax, donc ils sont considérés comme une seule fonction.

  >>> np.max.__name__
  'amax'
  >>> np.max is np.amax
  True

• np.maxpropage les NaN tout en np.nanmaxignorant les NaN.

  >>> np.max([np.nan, 3.14, -1])
  nan
  >>> np.nanmax([np.nan, 3.14, -1])
  3.14

II. Pour la comparaison élément par élément de deux tableaux

Propagateur NaNs np.maximumet son homologue ignorant NaNs np.fmax.

• Les deux fonctions nécessitent deux tableaux comme les deux premiers arguments positionnels avec lesquels comparer.

  # x1 and x2 must be the same shape or can be broadcast
  np.maximum(x1, x2, /, ...);
  np.fmax(x1, x2, /, ...)

• np.maximumpropage les NaN tout en np.fmaxignorant les NaN.

  >>> np.maximum([np.nan, 3.14, 0], [np.NINF, np.nan, 2.72])
  array([ nan,  nan, 2.72])
  >>> np.fmax([np.nan, 3.14, 0], [np.NINF, np.nan, 2.72])
  array([-inf, 3.14, 2.72])

• Les fonctions élémentaires sont np.ufunc( Universal Function ) , ce qui signifie qu'elles ont des propriétés spéciales que la fonction Numpy normale n'a pas.

  >>> type(np.maximum)
  <class 'numpy.ufunc'>
  >>> type(np.fmax)
  <class 'numpy.ufunc'>
  >>> #---------------#
  >>> type(np.max)
  <class 'function'>
  >>> type(np.nanmax)
  <class 'function'>

Et enfin, les mêmes règles s'appliquent aux quatre fonctions minimales associées:

• np.amin/np.min, np.nanmin;
• et np.minimum, np.fmin.

np.maximum compare non seulement élément par élément, mais compare également le tableau élément par élément à une valeur unique

>>>np.maximum([23, 14, 16, 20, 25], 18)
array([23, 18, 18, 20, 25])