Multiplication d'ensembles NumPy | Calcul scientifique Python

Introduction

NumPy est une bibliothèque puissante pour le calcul scientifique en Python. L'une des caractéristiques les plus importantes de NumPy est sa capacité à effectuer efficacement diverses types de multiplications d'arrays.

Dans ce tutoriel, nous allons explorer les différentes opérations de multiplication disponibles dans NumPy, y compris numpy.multiply, numpy.dot, numpy.matmul, l'opérateur * et l'opérateur @.

Commencer

Avant d'approfondir les différentes opérations de multiplication dans NumPy, commençons par ouvrir l'interpréteur Python en tapant la commande suivante dans le terminal.

python3

Ensuite, importons la bibliothèque et créons quelques tableaux d'échantillons que nous pouvons utiliser pour la démonstration.

import numpy as np

## Création de tableaux d'échantillons
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

Nous avons créé deux tableaux A et B, chacun avec deux lignes et deux colonnes. Maintenant, explorons les différentes opérations de multiplication disponibles dans NumPy.

numpy.multiply

La fonction numpy.multiply effectue une multiplication élément par élément entre deux tableaux. Les deux tableaux doivent avoir la même forme. Le tableau résultant aura la même forme que les tableaux d'entrée.

C = np.multiply(A, B)

print(C)
## Sortie :
## array([[ 5, 12],
##       [21, 32]])

Dans cet exemple, chaque élément de A est multiplié par l'élément correspondant de B, ce qui résulte en la multiplication élément par élément des deux tableaux.

numpy.dot

La fonction numpy.dot effectue une multiplication de matrices entre deux tableaux. Le premier tableau doit avoir le même nombre de colonnes que le second tableau a de lignes. Le tableau résultant aura le même nombre de lignes que le premier tableau et le même nombre de colonnes que le second tableau.

C = np.dot(A, B)

print(C)
## Sortie :
## array([[19, 22],
##        [43, 50]])

Dans cet exemple, nous avons effectué une multiplication de matrices entre les tableaux A et B. Le tableau résultant C a deux lignes et deux colonnes, comme prévu.

numpy.matmul

La fonction numpy.matmul effectue également une multiplication de matrices entre deux tableaux, mais elle a des règles légèrement différentes pour gérer les tableaux multidimensionnels. Les deux tableaux doivent avoir la même forme, sauf pour les deux dernières dimensions, qui doivent être conformes. Si l'un des tableaux est 1-D, il est promu à une matrice en ajoutant un 1 à sa forme.

C = np.matmul(A, B)

print(C)
## Sortie :
## array([[19, 22],
##        [43, 50]])

Dans cet exemple, nous obtenons le même résultat qu'avec numpy.dot. C'est parce que nos tableaux A et B ont la même forme, donc numpy.matmul se comporte de la même manière que numpy.dot.

Et voici un autre exemple différent :

## définir deux tableaux 3-D
a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
b = np.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])

c = np.matmul(a, b)
d = np.dot(a, b)

print(c)
## Sortie :
## array([[[ 31,  34],
##        [ 71,  78]],
##        [[155, 166],
##        [211, 226]]])

print(d)
## Sortie :
## array([[[[ 31,  34],
##         [ 43,  46]],
##        [[ 71,  78],
##         [ 99, 106]]],
##       [[[111, 122],
##         [155, 166]],
##        [[151, 166],
##         [211, 226]]]])

Dans cet exemple, numpy.matmul effectue l'opération de multiplication de matrices par lots.

Puisque a et b sont des tableaux 3-D, la sortie de numpy.dot aura une dimensionnalité $(2,2,2,2)$ . Les deux premières dimensions correspondent aux deux lots de matrices $2\times2$ dans a et b. Les deux dimensions suivantes correspondent au produit scalaire de chaque paire de matrices $2\times2$ dans les lots :

## le premier résultat 2 × 2
dot(a[0], b[0]) =
dot([[1, 2],
 [3, 4]],
 [[9, 10],
 [11, 12]]
= [[1*9 + 2*11, 1*10 + 2*12],
   [3*9 + 4*11, 3*10 + 4*12]]
= [[31, 34],
   [43, 46]]

Opérateur *

L'opérateur * effectue également une multiplication élément par élément entre deux tableaux, mais il se comporte légèrement différemment de numpy.multiply. Si les deux tableaux ont la même forme, l'opérateur * effectuera une multiplication élément par élément, tout comme numpy.multiply. Cependant, si l'un des tableaux est une valeur scalaire, l'opérateur * effectuera une multiplication scalaire sur chaque élément de l'autre tableau.

C = A * B
D = A * 2

print(C)
## Sortie :
#array([[ 5, 12],
##       [21, 32]])

print(D)
## Sortie :
## array([[2, 4],
##       [6, 8]])

Dans le premier exemple, nous obtenons le même résultat qu'avec numpy.multiply. Dans le second exemple, nous effectuons une multiplication scalaire sur chaque élément du tableau A.

Opérateur @

L'opérateur @ effectue une multiplication de matrices, tout comme numpy.dot et numpy.matmul. Il a été introduit en Python 3.5 comme un raccourci pour numpy.matmul.

C = A @ B

print(C)
## Sortie :
## array([[19, 22],
##       [43, 50]])

Dans cet exemple, nous utilisons l'opérateur @ pour effectuer une multiplication de matrices entre les tableaux A et B. Le tableau résultant C a deux lignes et deux colonnes, tout comme avec numpy.dot et numpy.matmul.

Sommaire

Dans ce tutoriel, nous avons exploré les différentes opérations de multiplication disponibles dans NumPy. Chacune de ces opérations a ses propres règles et cas d'utilisation, il est donc important de choisir la bonne pour votre tâche spécifique. En maîtrisant ces opérations, vous pouvez effectuer efficacement des multiplications d'ensembles et de matrices en Python à l'aide de NumPy.

Opérations de multiplication d'ensembles NumPy efficaces