Multiplication matricielle avec numpy

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

 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 ?

Salut,

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

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

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 ?

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 ?

Ça s'appelle « outer product ».

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.

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

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

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

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.

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

Mathématiquement tu peux écrire ce que tu veux ?

Bien sûr

Je reçois $e$ et $x$ qui sont deux vecteurs lignes de tailles respective $n$ et $p$. En maths j'écrirais : $e' \times x$ (c'est $e$ qui est transposé)

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.

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)

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.

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