Multiplication matricielle avec numpy

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

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

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

Édité par Ricocotam

+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 ?

http://nodraak.fr/ – Dictateur bienveillant de l'iTeam, logiciel libre et sécurité à l'ECE Paris

+3 -0
Auteur du sujet

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 ^^

+0 -0
Staff
 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

Édité par Gabbro

Hier, dans le parc, j'ai vu une petite vieille entourée de dinosaures aviens. Je donne pas cher de sa peau.

+0 -0
Staff

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 ?

Ce n’est pas en répétant « Hom, Hom », qu’on démontre des théorèmes sérieux - Siegel Mon Twitter

+0 -0
Staff

Ok mais le produit extérieur s'applique à deux vecteurs d'un même espace vectoriel de mémoire (ou à moins de partir sur des objets plus exotiques). Là il a deux dimensions différentes.

Édité par Holosmos

Ce n’est pas en répétant « Hom, Hom », qu’on démontre des théorèmes sérieux - Siegel Mon Twitter

+0 -0

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 ».

Édité par blo yhg

+0 -0
Staff

Ç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.

Édité par Holosmos

Ce n’est pas en répétant « Hom, Hom », qu’on démontre des théorèmes sérieux - Siegel Mon Twitter

+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).

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.

Édité par blo yhg

+0 -0
Staff

Bof. Outer product il me semble que ça dépend des auteurs. Mais de toute façon pour passer de l'un à l'autre suffit de faire une alternance.

Ce n’est pas en répétant « Hom, Hom », qu’on démontre des théorèmes sérieux - Siegel Mon Twitter

+0 -0
Auteur du sujet

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 :(

+0 -0
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 ^^)

http://nodraak.fr/ – Dictateur bienveillant de l'iTeam, logiciel libre et sécurité à l'ECE Paris

+0 -0
Staff

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.

Hier, dans le parc, j'ai vu une petite vieille entourée de dinosaures aviens. Je donne pas cher de sa peau.

+1 -0
Auteur du sujet

Donc je ne peux pas transformer un truc 1D en 2D ? Parce que j'ai peur que ça ajoute trop de problème en passant tout à 2D en permanence (je peux localement faire la manip de reshape, même si je sais pas comment faire)

+0 -0
Staff

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. ^^

Hier, dans le parc, j'ai vu une petite vieille entourée de dinosaures aviens. Je donne pas cher de sa peau.

+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)
+0 -0
Auteur du sujet

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 :)

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

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