numpy
numpy.dot

Syntaxe

• numpy.dot (a, b, out = None)

Paramètres

Remarques

Multiplication de matrice

La multiplication matricielle peut se faire de deux manières équivalentes avec la fonction point. L'une des méthodes consiste à utiliser la fonction membre dot de numpy.ndarray.

>>> import numpy as np
>>> A = np.ones((4,4))
>>> A
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])
>>> B = np.ones((4,2))
>>> B
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])
>>> A.dot(B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

La deuxième façon de procéder à la multiplication matricielle est d'utiliser la fonction de bibliothèque numpy.

>>> np.dot(A,B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

Produits de points Vector

La fonction de point peut également être utilisée pour calculer des produits de points vectoriels entre deux tableaux numpy unidimensionnels.

>>> v = np.array([1,2])
>>> w = np.array([1,2])
>>> v.dot(w)
5
>>> np.dot(w,v)
5
>>> np.dot(v,w)
5

Le paramètre out

La fonction numpy dot a un paramètre optionnel out = None. Ce paramètre vous permet de spécifier un tableau dans lequel écrire le résultat. Ce tableau doit avoir exactement la même forme et le même type que le tableau qui aurait été renvoyé, ou une exception sera lancée.

>>> I = np.eye(2)
>>> I
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result = np.zeros((2,2))
>>> result
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> np.dot(I, I, out=result)
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result
array([[ 1.,  0.],
       [ 0.,  1.]])

Essayons de changer le type de résultat en int.

>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

Et si nous essayons d'utiliser un ordre de mémoire sous-jacent différent, disons le style Fortran (pour que les colonnes soient contiguës au lieu de lignes), une erreur se produit également.

>>> result = np.zeros((2,2), order='F')
>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

Opérations matricielles sur des tableaux de vecteurs

numpy.dot peut être utilisé pour multiplier une liste de vecteurs par une matrice mais l'orientation des vecteurs doit être verticale pour qu'une liste de huit vecteurs à deux composantes apparaisse comme deux vecteurs de composants:

>>> a
array([[ 1.,  2.],
       [ 3.,  1.]])
>>> b
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.],
       [  9.,  10.,  11.,  12.,  13.,  14.,  15.,  16.]])
>>> np.dot(a, b)
array([[ 19.,  22.,  25.,  28.,  31.,  34.,  37.,  40.],
       [ 12.,  16.,  20.,  24.,  28.,  32.,  36.,  40.]])

Si la liste des vecteurs est disposée avec ses axes dans le sens inverse (ce qui est souvent le cas), alors le tableau doit être transposé avant et après l'opération de point comme ceci:

>>> b
array([[  1.,   9.],
       [  2.,  10.],
       [  3.,  11.],
       [  4.,  12.],
       [  5.,  13.],
       [  6.,  14.],
       [  7.,  15.],
       [  8.,  16.]])
>>> np.dot(a, b.T).T
array([[ 19.,  12.],
       [ 22.,  16.],
       [ 25.,  20.],
       [ 28.,  24.],
       [ 31.,  28.],
       [ 34.,  32.],
       [ 37.,  36.],
       [ 40.,  40.]])

Bien que la fonction de point soit très rapide, il est parfois préférable d’utiliser einsum. L'équivalent de ce qui précède serait:

>>> np.einsum('...ij,...j', a, b)

Ce qui est un peu plus lent mais permet de multiplier une liste de sommets par une liste de matrices correspondante. Ce serait un processus très compliqué en utilisant dot:

>>> a
array([[[ 0,  1],
        [ 2,  3]],
       [[ 4,  5],
        [ 6,  7]],
       [[ 8,  9],
        [10, 11]],
       [[12, 13],
        [14, 15]],
       [[16, 17],
        [18, 19]],
       [[20, 21],
        [22, 23]],
       [[24, 25],
        [26, 27]],
       [[28, 29],
        [30, 31]]])
>>> np.einsum('...ij,...j', a, b)
array([[   9.,   29.],
       [  58.,   82.],
       [ 123.,  151.],
       [ 204.,  236.],
       [ 301.,  337.],
       [ 414.,  454.],
       [ 543.,  587.],
       [ 688.,  736.]])

numpy.dot peut être utilisé pour trouver le produit scalaire de chaque vecteur dans une liste avec un vecteur correspondant dans une autre liste, ce qui est assez désordonné et lent comparé à la multiplication par éléments et à la sommation le long du dernier axe. Quelque chose comme ça (ce qui nécessite un tableau beaucoup plus grand pour être calculé mais généralement ignoré)

>>> np.diag(np.dot(b,b.T))
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

Produit Dot utilisant la multiplication et la sommation par éléments

>>> (b * b).sum(axis=-1)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

Utiliser einsum pourrait être réalisé avec

>>> np.einsum('...j,...j', b, b)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])