Multiplication matricielle avec numpy

C'est pas très clair tout ça, encore moins en anglais

a marqué ce sujet comme résolu.

Bonjour bonjour, je voudrais dans mon code faire un multiplication entre deux vecteurs. Une vraie multiplication au sens matricielle. Sauf que tout ce que je trouve concerne ce fichu "dot product" qui n'a absolument rien d'un produit matriciel puisqu'il est complètement commutatif. J'ai essayé tout ce que je trouvais : prod, dot, multiply, cross, * : Bref, rien de tout ça n'est une vraie multiplication matricielle.

Je serais bien heureux de savoir comment vous faites ^^, merci d'avance :)

Edit : je parle bien de veteur et non de matrice. Si j'ai un vecteur ligne et taille $n$ et un vecteur colonne et taille $p$, dans un sens ça me donne une matrice avec $p$ lignes et $n$ colonnes, dans l'autre ça me donne le produit scalaire entre les deux vecteurs. C'est le premier sens qui m'intéresse

+0 -0
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
>>> import numpy as np
>>> a = np.array([[1, 2, 3]])
>>> b = np.array([[4], [5], [6]])
>>> a
array([[1, 2, 3]])
>>> b
array([[4],
       [5],
       [6]])
>>> a.shape
(1, 3)
>>> b.shape
(3, 1)
>>> np.dot(a, b)
array([[32]])
>>> np.dot(b, a)
array([[ 4,  8, 12],
       [ 5, 10, 15],
       [ 6, 12, 18]])

Comme ça ?

Comme ça ?

Nodraak

Oui comme ça ! Bon je suis pas fou alors tout va bien. J'avais essayé en utilisant la fonction "transpose" mais ça ne semble pas fonctionner, une idée ?

Merci beaucoup :)

Salut,

Tu seras aussi sûrement intéressé par les vraies matrices de numpy.

Aabu

J'ai vu passer mais pour le peu de code (50 lignes à tout péter avec les commentaires verbeux) que j'ai je préfère me contenter des np.array que je connais un peu plus ^^

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
>>> import numpy as np
>>> a = np.array([[1, 2, 3]])
>>> b = np.array([[4, 5, 6]]).transpose()
>>> a
array([[1, 2, 3]])
>>> b
array([[4],
       [5],
       [6]])
>>> a.shape
(1, 3)
>>> b.shape
(3, 1)
>>> np.dot(a, b)
array([[32]])
>>> np.dot(b, a)
array([[ 4,  8, 12],
       [ 5, 10, 15],
       [ 6, 12, 18]])

Comme ça ? :P

+0 -0

Bonjour bonjour, je voudrais dans mon code faire un multiplication entre deux vecteurs. Une vraie multiplication au sens matricielle.

De quelle multiplication tu parles ?

Sauf que tout ce que je trouve concerne ce fichu "dot product" qui n'a absolument rien d'un produit matriciel puisqu'il est complètement commutatif.

Est-ce vraiment un problème ?

Banni

Non, pas forcément : sur wikipédia.

Mais sinon, je ne comprends pas sous quel format les vecteurs sont stockés. Si c'est sous forme « vecteur-colonne » et « ligne », alors c'est pas vraiment des vecteurs, c'est des matrices spéciales et le produit matriciel normal devrait marcher comme montré plus haut. Et sinon, alors il n'y a pas de « ligne » ou « colonne ». Ah ok, mal lu.

PS : je trouve le nom français bizarre : « produit dyadique ».

+0 -0

Ça c'est le produit tensoriel. Et effectivement on peut le faire sur des espaces différents (mais ça devient un petit peu exotique, personnellement je croise rarement des espaces qui sont pas isomorphes).

Pour le produit extérieur j'ai un doute du coup. Ça doit peut-être se faire.

Mais il n'empêche que je suis curieux de l'utilisation que Ricocotam veut en faire. C'est rarement trivial les utilisations de ces objets.

+0 -0
Banni

Ça c'est le produit tensoriel. Et effectivement on peut le faire sur des espaces différents (mais ça devient un petit peu exotique, personnellement je croise rarement des espaces qui sont pas isomorphes).

Justement c'est la même chose, la traduction française de « outer product » n'est pas « produit extérieur » mais « produit dyadique ». Ah bon, on peut faire sur des espaces différents le produit extérieur ? Que devient l'antisymétrie ? Désolé, j'ai encore lu trop vite.

Mais il n'empêche que je suis curieux de l'utilisation que Ricocotam veut en faire. C'est rarement trivial les utilisations de ces objets.

Pour faire des projections c'est utile, par exemple pour coder une décomposition QR j'avais utilisé np.outer.

+0 -0

Voilà mon problème :

1
2
3
4
5
6
7
>>> a = np.array([1,2,3])
>>> b = np.array([1,2,3])
>>> b = b.transpose()
>>> np.dot(a, b)
14
>>> np.dot(b, a)
14

Je reçois des np.array avec comme shape (n,). Y en a un que j'aimerais transposer pour avoir une matrice après. Mais vous voyez bien que ça marche pas :(

1
2
>>> np.array == np.matrix
False

Démonstration:

 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
>>> import numpy as np
>>> a = np.array([1, 2, 3])
>>> b = np.array([[1, 2, 3]])
>>> c = np.matrix([1, 2, 3])
>>> d = np.matrix([[1, 2, 3]])
>>> a
array([1, 2, 3])
>>> b
array([[1, 2, 3]])
>>> c
matrix([[1, 2, 3]])
>>> d
matrix([[1, 2, 3]])
>>> a.transpose()
array([1, 2, 3])
>>> b.transpose()
array([[1],
       [2],
       [3]])
>>> c.transpose()
matrix([[1],
        [2],
        [3]])
>>> d.transpose()
matrix([[1],
        [2],
        [3]])

(J'aime le shell Python ^^)

Si tu écris a = np.array([1,2,3]), tu travailles en 1D, point barre. Si tu veux une matrice, il faut travailler avec une matrice 2D à une ligne et une autre à une colonne. Donc,

1
2
3
4
5
6
7
8
9
a = np.array([[1,2,3]])
b = np.array([[1,2,3]])
b = b.transpose()
np.dot(a, b)
# array([[14]])
np.dot(b, a)
# array([[1, 2, 3],
#        [2, 4, 6],
#        [3, 6, 9]])

Note bien le double crochet lors de la définition.

+1 -0

Tu peux faire

1
2
3
4
5
6
a = np.array([1,2,3])
b = np.array([1,2,3]).transpose()
np.dot(np.reshape(a, (3,1)), np.reshape(b, (1,3)))
# array([[1, 2, 3],
#        [2, 4, 6],
#        [3, 6, 9]])

même si je ne suis pas convaincu que ça te convienne. ^^

+0 -0

Si par multiplication matricielle tu entends "matrix multiplication".

La PEP 465 peut éventuellement t'aider, il y a ces exemples, avec NumPy :

Now we need to write code to perform this calculation. In current numpy, matrix multiplication can be performed using either the function or method call syntax. Neither provides a particularly readable translation of the formula:

1
2
3
4
5
6
7
8
9
import numpy as np
from numpy.linalg import inv, solve

# Using dot function:
S = np.dot((np.dot(H, beta) - r).T,
           np.dot(inv(np.dot(np.dot(H, V), H.T)), np.dot(H, beta) - r))

# Using dot method:
S = (H.dot(beta) - r).T.dot(inv(H.dot(V).dot(H.T))).dot(H.dot(beta) - r)

Et un jour, tu pourras écrire, de façon plus compacte :

1
S = (H @ beta - r).T @ inv(H @ V @ H.T) @ (H @ beta - r)

Je dois définitivement pas avoir la même version de numpy que vous. Je vais écrire le code tel qu'il devrait être et puis tant pis xD. C'est pour mettre dans un dossier donc tant pis.

Sinon pour la PEP, j'avoue que c'est quand même plus simple la deuxième écriture ^^

Merci quand même :)

Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte