web-dev-qa-db-fra.com

numpy max vs amax vs maximum

numpy a trois fonctions différentes qui semblent pouvoir être utilisées pour les mêmes choses --- sauf que numpy.maximum peut niquement être utilisé élément par élément, tandis que numpy.max et numpy.amax peut être utilisé sur des axes particuliers ou sur tous les éléments. Pourquoi y a-t-il plus que juste numpy.max? Y at-il une certaine subtilité dans cette performance?

(De même pour min vs. amin vs. minimum)

pythonnumpymathmax
94
DilithiumMatrix

_np.max_ est simplement un alias pour _np.amax_. Cette fonction ne fonctionne que sur un tableau d'entrée unique et trouve la valeur de l'élément maximum dans l'ensemble de ce tableau (retourne un scalaire). Sinon, il utilise un argument axis et recherche la valeur maximale le long d'un axe du tableau en entrée (retourne 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.maximum_ consiste à prendre deux tableaux et à calculer leur maximum par élément. Ici, "compatible" signifie qu'un tableau peut être diffusé à 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.maximum_ est également une fonction universelle , ce qui signifie qu’il a d’autres fonctionnalités et méthodes utiles pour les tableaux multidimensionnels. Par exemple, vous pouvez calculer le maximum cumulatif 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])
_

Ceci n'est pas possible avec _np.max_.

Vous pouvez faire _np.maximum_ imiter _np.max_ dans une certaine mesure lorsque vous utilisez _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, car np.max() APPELLE RÉELLEMENT _np.maximum.reduce pour effectuer le calcul.

115
Alex Riley

Vous avez déjà expliqué pourquoi np.maximum est différent: il renvoie un tableau représentant le maximum élémentaire entre deux tableaux.

En ce qui concerne np.amax et np.max: ils appellent tous les deux la même fonction - np.max n'est qu'un alias pour np.amax et 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>
16
tmdavison

Pour être complet, dans Numpy, il existe quatre fonctions liées maximum. Ils tombent dans deux catégories différentes:

  • _np.amax/np.max_, _np.nanmax_: pour tableau unique statistiques d'ordre
  • et _np.maximum_, _np.fmax_: pour la comparaison élément par élément de deux tableaux

I. Pour tableau unique statistiques d'ordre

NaNs propagator np.amax/np.max et son homologue ignorant NaN np.nanmax.

  • _np.max_ est simplement un alias de _np.amax_, ils sont donc considérés comme une seule et même fonction.

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

  • _np.max_ propage les NaN tandis que _np.nanmax_ ignore les NaN.

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

II. Pour la comparaison élémentaire de deux tableaux

NaNs propagator np.maximum et son homologue ignorant NaNs np.fmax.

  • Les deux fonctions requièrent deux tableaux comme comparaison avec les deux premiers arguments de position.

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

  • _np.maximum_ propage les NaN tandis que _np.fmax_ ignore 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_ ( Fonction universelle ) , ce qui signifie qu'elles ont des propriétés spéciales qui sont normales La fonction Numpy 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'>
_

Enfin, les mêmes règles s’appliquent aux quatre fonctions connexes minimum:

  • _np.amin/np.min_, _np.nanmin_;
  • et _np.minimum_, _np.fmin_.
1
YaOzI