numpy max vs amax vs maximum


132

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)

Réponses:


164

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.


1
Merci. Évidemment, on peut utiliser amaxpour le même but (racine) que maximum, c'est-à-dire avec numpy.amax([a1, a2], axis=0)--- mais n'est-ce pas aussi optimisé pour ce comportement que numpy.maximum? De même, les subtilités ajoutées de numpy.amax(par exemple le axisparamètre) l'empêchent-elles d'être un ufunc?
DilithiumMatrix

1
C'est vrai, amaxn'est pas optimisé pour la comparaison élémentaire dans ce cas - toute entrée devra être un tableau Numpy, de sorte que la liste serait convertie avant l'exécution de l'opération (en supposant que les deux formes soient identiques). Les documents pour amaxspécifiquement disent que maximumc'est plus rapide ici.
Alex Riley

Sur la deuxième question: je suppose que cela amax pourrait être transformé en ufunc, bien que le but principal des ufuncs soit de permettre aux opérations d'être diffusées entre les tableaux. Il semble peu nécessaire de créer maxun ufunc unaire. Je pense amaxqu'existait avant que les ufuncs ne soient vraiment une chose (cela venait du numérique, le parent de NumPy) donc est également conservé pour la postérité.
Alex Riley

Voici maximum.reduce préféré pour la performance: The Python function max() will find the maximum over a one-dimensional array, but it will do so using a slower sequence interface. The reduce method of the maximum ufunc is much faster. Also, the max() method will not give answers you might expect for arrays with greater than one dimension.[...]
Tom Hale

1
@TomHale: Je pense que la documentation fait référence à la max()fonction intégrée Python , plutôt qu'à numpy.max(), mais il vaut vraiment la peine de souligner que Python max()est plus lent.
Alex Riley

21

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>

2
Je me sens stupide maintenant, je faisais from numpy import max as np_maxjuste pour éviter les conflits avec le générique maxtout le temps alors que j'aurais pu simplement utiliser des amax peaux .
Bas Jansen

8

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.

0

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])
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.