web-dev-qa-db-fra.com

Quelles sont les différences entre les tableaux numpy et les matrices? Lequel devrais-je utiliser?

Quels sont les avantages et les inconvénients de chacun?

D'après ce que j'ai vu, l'un ou l'autre peut fonctionner en remplacement de l'autre si besoin est, alors devrais-je m'embêter à utiliser les deux ou devrais-je m'en tenir à l'un d'entre eux?

Le style du programme va-t-il influencer mon choix? Je suis en train d'apprendre à utiliser numpy, il y a donc beaucoup de matrices, mais aussi beaucoup de vecteurs (tableaux).

307
levesque

Les matrices Numpy sont strictement bidimensionnelles, alors que les tableaux numpy (ndarrays) sont à N dimensions. Les objets Matrix sont une sous-classe de ndarray. Ils héritent donc de tous les attributs et méthodes de ndarrays.

Le principal avantage des matrices numpy est qu'elles fournissent une notation pratique pour la multiplication matricielle: si a et b sont des matrices, alors a * b est leur produit matriciel.

import numpy as np

a=np.mat('4 3; 2 1')
b=np.mat('1 2; 3 4')
print(a)
# [[4 3]
#  [2 1]]
print(b)
# [[1 2]
#  [3 4]]
print(a*b)
# [[13 20]
#  [ 5  8]]

D'autre part, à partir de Python 3.5, NumPy prend en charge la multiplication matricielle infixe à l'aide de l'opérateur @, de sorte que vous puissiez obtenir le même confort de multiplication matricielle avec ndarrays dans Python. > = 3.5.

import numpy as np

a=np.array([[4, 3], [2, 1]])
b=np.array([[1, 2], [3, 4]])
print(a@b)
# [[13 20]
#  [ 5  8]]

Les objets matriciels et ndarrays ont .T pour renvoyer la transposition, mais les objets matriciels ont également .H pour la transposée conjuguée et .I pour l'inverse.

En revanche, les tableaux numpy respectent systématiquement la règle selon laquelle les opérations sont appliquées élément par élément (à l'exception du nouvel opérateur @.). Ainsi, si a et b sont des tableaux numpy, alors a*b est le tableau formé en multipliant les composants par élément:

c=np.array([[4, 3], [2, 1]])
d=np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]

Pour obtenir le résultat de la multiplication de matrice, utilisez np.dot (ou @ dans Python> = 3.5, comme indiqué ci-dessus):

print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]

L'opérateur ** se comporte également différemment:

print(a**2)
# [[22 15]
#  [10  7]]
print(c**2)
# [[16  9]
#  [ 4  1]]

Puisque a est une matrice, a**2 renvoie le produit matriciel a*a. Puisque c est un ndarray, c**2 renvoie un ndarray avec chaque composant au carré, élément par élément.

Il existe d'autres différences techniques entre les objets de la matrice et ndarrays (concernant np.ravel, la sélection d'éléments et le comportement de la séquence).

Le principal avantage des tableaux numpy est qu'ils sont plus généraux que les matrices bidimensionnelles. Qu'est-ce qui se passe quand vous voulez un tableau en 3 dimensions? Ensuite, vous devez utiliser un ndarray, pas un objet de matrice. Ainsi, apprendre à utiliser des objets matriciels représente plus de travail - vous devez apprendre les opérations relatives aux objets matriciels et les opérations ndarray.

Écrire un programme qui utilise à la fois des matrices et des tableaux vous rend la vie difficile, car vous devez savoir quel type d’objet sont vos variables afin que la multiplication ne renvoie pas un résultat inattendu.

En revanche, si vous vous en tenez uniquement à ndarrays, vous pouvez faire tout ce que les objets matriciels peuvent faire, et plus, sauf avec des fonctions/notations légèrement différentes.

Si vous êtes prêt à abandonner l’attrait visuel de la notation des produits matriciels NumPy (ce qui peut être obtenu avec une élégance presque identique avec ndarrays dans Python> = 3.5), je pense que les tableaux NumPy sont définitivement la voie à suivre.

PS Bien sûr, vous n’avez vraiment pas à choisir l’un au détriment de l’autre, car np.asmatrix et np.asarray vous permettent de convertir l’un en l’autre (tant que le tableau est en 2 dimensions). .


Il existe un résumé des différences entre NumPy arrays et NumPy matrixes ici .

363
unutbu

Scipy.org vous recommande d'utiliser des tableaux:

* 'tableau' ou 'matrice'? Que devrais-je utiliser? - réponse courte

Utilisez des tableaux.

  • Ils sont le type standard de numpy vecteur/matrice/tenseur. Beaucoup de fonctions numpy retournent des tableaux, pas des matrices.

  • Il existe une distinction claire entre les opérations par élément et les opérations en algèbre linéaire.

  • Vous pouvez avoir des vecteurs standard ou des vecteurs de lignes/colonnes si vous le souhaitez.

Le seul inconvénient de l'utilisation du type tableau est que vous devrez utiliser dot au lieu de * pour multiplier (réduire) deux tenseurs (produit scalaire, multiplication vecteur matriciel, etc.).

83
atomh33ls

Juste pour ajouter un cas à la liste de unutbu.

L'une des plus grandes différences pratiques entre numpy et ndarrays par rapport aux matrices numpy ou aux langages matriciels tels que matlab est que la dimension n'est pas conservée dans les opérations de réduction. Les matrices sont toujours 2d, tandis que la moyenne d'un tableau, par exemple, a une dimension en moins.

Par exemple, diminuez les lignes d'une matrice ou d'un tableau:

avec matrice

>>> m = np.mat([[1,2],[2,3]])
>>> m
matrix([[1, 2],
        [2, 3]])
>>> mm = m.mean(1)
>>> mm
matrix([[ 1.5],
        [ 2.5]])
>>> mm.shape
(2, 1)
>>> m - mm
matrix([[-0.5,  0.5],
        [-0.5,  0.5]])

avec tableau

>>> a = np.array([[1,2],[2,3]])
>>> a
array([[1, 2],
       [2, 3]])
>>> am = a.mean(1)
>>> am.shape
(2,)
>>> am
array([ 1.5,  2.5])
>>> a - am #wrong
array([[-0.5, -0.5],
       [ 0.5,  0.5]])
>>> a - am[:, np.newaxis]  #right
array([[-0.5,  0.5],
       [-0.5,  0.5]])

Je pense aussi que le mélange de matrices et de matrices donne lieu à de nombreuses heures de "mise au point" de dépannage Cependant, les matrices scipy.sparse sont toujours des matrices en termes d'opérateurs comme la multiplication.

28
Josef

Comme d'autres l'ont mentionné, le principal avantage de matrix était qu'elle fournissait une notation pratique pour la multiplication de matrices.

Cependant, dans Python 3.5, il existe enfin un opérateur infixe dédié à la multiplication matricielle : @.

Avec les versions récentes de NumPy, il peut être utilisé avec ndarrays:

A = numpy.ones((1, 3))
B = numpy.ones((3, 3))
A @ B

Donc maintenant, encore plus, en cas de doute, vous devriez vous en tenir à ndarray.

18
Peque