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 nécessaire, alors devrais-je prendre la peine d'utiliser les deux ou devrais-je m'en tenir à l'un d'entre eux?

Le style du programme influencera-t-il mon choix? Je fais un peu d'apprentissage automatique en utilisant numpy, donc il y a en effet beaucoup de matrices, mais aussi beaucoup de vecteurs (tableaux).

Selon les documents officiels, il n'est plus conseillé d'utiliser la classe de matrice car elle sera supprimée à l'avenir.

https://numpy.org/doc/stable/reference/generated/numpy.matrix.html

Comme d'autres réponses indiquent déjà que vous pouvez réaliser toutes les opérations avec les tableaux NumPy.

Les matrices numpy sont strictement bidimensionnelles, tandis que les tableaux numpy numpy (ndarrays) sont N-dimensionnels. Les objets matriciels sont une sous-classe de ndarray, ils héritent donc de tous les attributs et méthodes des 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*best 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'un autre côté, à partir de Python 3.5, NumPy prend en charge la multiplication de matrice infixe à l'aide de l' @opérateur, de sorte que vous pouvez obtenir la même commodité de multiplication matricielle avec ndarrays en 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 les ndarrays doivent tous .Tles deux renvoyer la transposition, mais les objets matriciels doivent également être utilisés .Hpour la transposition conjuguée et .Ipour l'inverse.

En revanche, les tableaux numpy respectent systématiquement la règle selon laquelle les opérations sont appliquées par élément (sauf pour le nouvel @opérateur). Ainsi, si aet bsont des tableaux numpy, alors a*ble tableau est 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 matricielle, vous utilisez np.dot(ou @en 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 aest une matrice, a**2renvoie le produit matriciel a*a. Puisque cest un ndarray, c**2retourne un ndarray avec chaque composant au carré élément par élément.

Il existe d'autres différences techniques entre les objets matriciels et les ndarrays (concernant la np.ravelsélection des éléments et le comportement des séquences).

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

Écrire un programme qui mélange à la fois des matrices et des tableaux vous rend la vie difficile car vous devez garder une trace du type d'objet de vos variables, de peur que la multiplication ne renvoie quelque chose que vous n'attendez pas.

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

Si vous êtes prêt à renoncer à l'attrait visuel de la notation des produits matriciels NumPy (qui peut être atteint presque aussi élégamment avec des ndarrays en Python> = 3,5), alors je pense que les tableaux NumPy sont certainement la voie à suivre.

PS. Bien sûr, vous n'avez vraiment pas à en choisir un au détriment de l'autre, np.asmatrixet np.asarrayvous permettant de convertir l'un à l'autre (tant que le tableau est en 2 dimensions).

Il y a un résumé des différences entre NumPy arrayset NumPy matrixes ici .

Scipy.org vous recommande d'utiliser des tableaux:

* 'tableau' ou 'matrice'? Que dois-je utiliser? - Réponse courte

Utilisez des tableaux.

• Ce sont les numpy de type vecteur / matrice / tensor standard. Beaucoup de fonctions numpy retournent des tableaux, pas des matrices.

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

• Vous pouvez avoir des vecteurs standard ou des vecteurs ligne / colonne si vous le souhaitez.

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

Juste pour ajouter un cas à la liste d'unutbu.

L'une des plus grandes différences pratiques pour moi des ndarrays numpy par rapport aux matrices numpy ou aux langages matriciels comme matlab, est que la dimension n'est pas préservé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 de moins.

Par exemple, rabaisser 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 également que le mélange de tableaux et de matrices donne lieu à de nombreuses heures de débogage "heureuses". Cependant, les matrices scipy.sparse sont toujours des matrices en termes d'opérateurs comme la multiplication.

Comme d'autres l'ont mentionné, le principal avantage de matrixcette méthode est peut-être qu'elle fournit une notation pratique pour la multiplication matricielle.

Cependant, dans Python 3.5, il existe enfin un opérateur d'infixe dédié pour 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

De nos jours, encore plus, en cas de doute, vous devez vous en tenir ndarray.