Comparaison de deux tableaux NumPy pour l'égalité, par élément

Quelle est la manière la plus simple de comparer deux tableaux NumPy pour l'égalité (où l'égalité est définie comme: A = B ssi pour tous les indices i:) A[i] == B[i]?

Utiliser simplement ==me donne un tableau booléen:

 >>> numpy.array([1,1,1]) == numpy.array([1,1,1])

array([ True,  True,  True], dtype=bool)

Dois-je utiliser andles éléments de ce tableau pour déterminer si les tableaux sont égaux, ou existe-t-il un moyen plus simple de comparer?

(A==B).all()

tester si toutes les valeurs du tableau (A == B) sont vraies.

Remarque: vous souhaitez peut-être également tester les formes A et B, telles que A.shape == B.shape

Cas spéciaux et alternatives (d'après la réponse de dbaupp et le commentaire de yoavram)

Il convient de noter que:

• cette solution peut avoir un comportement étrange dans un cas particulier: si l'un Aou l' autre Best vide et que l'autre contient un seul élément, alors il revient True. Pour une raison quelconque, la comparaison A==Brenvoie un tableau vide, pour lequel l' allopérateur revient True.
• Un autre risque est que si Aet Bn'ont pas la même forme et ne sont pas diffusables, cette approche soulèvera une erreur.

En conclusion, si vous avez un doute sur la forme Aet la Bforme ou si vous voulez simplement être en sécurité: utilisez l'une des fonctions spécialisées:

np.array_equal(A,B)  # test if same shape, same elements values
np.array_equiv(A,B)  # test if broadcastable shape, same elements values
np.allclose(A,B,...) # test if same shape, elements have close enough values

La (A==B).all()solution est très soignée, mais il existe des fonctions intégrées pour cette tâche. À savoir array_equal, allcloseet array_equiv.

(Bien que certains tests rapides avec timeitsemblent indiquer que la (A==B).all()méthode est la plus rapide, ce qui est un peu particulier, étant donné qu'elle doit allouer un tout nouveau tableau.)

Mesurons les performances en utilisant le morceau de code suivant.

import numpy as np
import time

exec_time0 = []
exec_time1 = []
exec_time2 = []

sizeOfArray = 5000
numOfIterations = 200

for i in xrange(numOfIterations):

    A = np.random.randint(0,255,(sizeOfArray,sizeOfArray))
    B = np.random.randint(0,255,(sizeOfArray,sizeOfArray))

    a = time.clock() 
    res = (A==B).all()
    b = time.clock()
    exec_time0.append( b - a )

    a = time.clock() 
    res = np.array_equal(A,B)
    b = time.clock()
    exec_time1.append( b - a )

    a = time.clock() 
    res = np.array_equiv(A,B)
    b = time.clock()
    exec_time2.append( b - a )

print 'Method: (A==B).all(),       ', np.mean(exec_time0)
print 'Method: np.array_equal(A,B),', np.mean(exec_time1)
print 'Method: np.array_equiv(A,B),', np.mean(exec_time2)

Production

Method: (A==B).all(),        0.03031857
Method: np.array_equal(A,B), 0.030025185
Method: np.array_equiv(A,B), 0.030141515

Selon les résultats ci-dessus, les méthodes numpy semblent être plus rapides que la combinaison de l' opérateur == et de la méthode all () et en comparant les méthodes numpy, la plus rapide semble être la méthode numpy.array_equal .

Si vous voulez vérifier si deux tableaux ont le même shapeET elementsvous devez utiliser np.array_equalcar c'est la méthode recommandée dans la documentation.

En termes de performances, ne vous attendez pas à ce qu'un contrôle d'égalité en batte un autre, car il n'y a pas beaucoup de place à optimiser comparing two elements. Juste pour le plaisir, j'ai quand même fait des tests.

import numpy as np
import timeit

A = np.zeros((300, 300, 3))
B = np.zeros((300, 300, 3))
C = np.ones((300, 300, 3))

timeit.timeit(stmt='(A==B).all()', setup='from __main__ import A, B', number=10**5)
timeit.timeit(stmt='np.array_equal(A, B)', setup='from __main__ import A, B, np', number=10**5)
timeit.timeit(stmt='np.array_equiv(A, B)', setup='from __main__ import A, B, np', number=10**5)
> 51.5094
> 52.555
> 52.761

Donc à peu près égal, pas besoin de parler de vitesse.

Le (A==B).all()se comporte à peu près comme l'extrait de code suivant:

x = [1,2,3]
y = [1,2,3]
print all([x[i]==y[i] for i in range(len(x))])
> True

Habituellement, deux tableaux auront quelques petites erreurs numériques,

Vous pouvez utiliser numpy.allclose(A,B), au lieu de (A==B).all(). Cela renvoie un bool True / False

Maintenant, utilisez np.array_equal. De la documentation:

np.array_equal([1, 2], [1, 2])
True
np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
np.array_equal([1, 2], [1, 2, 3])
False
np.array_equal([1, 2], [1, 4])
False