3 façons de multiplier les matrices en Python

Dans ce didacticiel, vous apprendrez à multiplier deux matrices en Python.

Vous commencerez par apprendre la condition de multiplication matricielle valide et écrirez une fonction Python personnalisée pour multiplier les matrices. Ensuite, vous verrez comment vous pouvez obtenir le même résultat en utilisant des listes imbriquées.

Enfin, vous procéderez à l'utilisation NumPy et ses fonctions intégrées pour effectuer plus efficacement la multiplication matricielle.

Comment vérifier si la multiplication matricielle est valide

Avant d'écrire du code Python pour la multiplication matricielle, revenons sur les bases de la multiplication matricielle.

La multiplication matricielle entre deux matrices A et B n'est valide que si la le nombre de colonnes dans la matrice A is égal à la Nombre de rangées dans la matrice B.

Vous auriez probablement déjà rencontré cette condition pour la multiplication matricielle. Cependant, vous êtes-vous déjà demandé pourquoi c'est le cas?

Eh bien, c'est à cause de la façon dont fonctionne la multiplication matricielle. Regardez l'image ci-dessous.

Dans notre exemple générique, la matrice A a m lignes et n Colonnes. Et la matrice B a n lignes et p colonnes.

Quelle est la forme de la matrice de produits ?

L'élément à l'indice (i, j) dans la matrice résultante C est le produit scalaire de la ligne i de la matrice A et de la colonne j de la matrice B.

Donc, pour obtenir un élément à un indice particulier dans la matrice résultante C, vous devrez calculer le produit scalaire de la ligne et de la colonne correspondantes dans les matrices A et B, respectivement.

En répétant le processus ci-dessus, vous obtiendrez la matrice produit C de forme mxp-avec m lignes et p colonnes, comme indiqué ci-dessous.

Et le produit scalaire ou le produit scalaire entre deux vecteurs a et b est donnée par l'équation suivante.

Résumons maintenant :

• Il est évident que le produit scalaire n'est défini qu'entre des vecteurs de longueur égale.
• Ainsi, pour que le produit scalaire entre une ligne et une colonne soit valide - lors de la multiplication de deux matrices - vous auriez besoin qu'elles aient toutes les deux le même nombre d'éléments.
• Dans l'exemple générique ci-dessus, chaque ligne de la matrice A a n éléments. Et chaque colonne de la matrice B a n éléments aussi.

Si vous regardez de plus près, n est le nombre de colonnes dans la matrice A, et c'est aussi le nombre de lignes dans la matrice B. Et c'est précisément la raison pour laquelle vous avez besoin du le nombre de colonnes dans la matrice A être égal à la Nombre de rangées dans la matrice B.

J'espère que vous comprenez la condition pour que la multiplication matricielle soit valide et comment obtenir chaque élément de la matrice produit.

Continuons à écrire du code Python pour multiplier deux matrices.

Write a Custom Python Function to Multiply Matrices

Dans un premier temps, écrivons une fonction personnalisée pour multiplier les matrices.

Cette fonction doit effectuer les opérations suivantes :

• Acceptez deux matrices, A et B, comme entrées.
• Vérifiez si la multiplication matricielle entre A et B est valide.
• Si valide, multipliez les deux matrices A et B, et retournez la matrice produit C.
• Sinon, renvoie un message d'erreur indiquant que les matrices A et B ne peuvent pas être multipliées.

Étape 1: Générer deux matrices d'entiers à l'aide de NumPy random.randint() une fonction. Vous pouvez également déclarer des matrices en tant que listes Python imbriquées.

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Étape 2 : Allez-y et définissez la fonction multiply_matrix(A,B). Cette fonction prend en deux matrices A et B comme entrées et renvoie la matrice produit C si la multiplication matricielle est valide.

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Analyse de la définition de la fonction

Passons à l'analyse de la définition de la fonction.

Déclarer C comme variable globale: Par défaut, toutes les variables à l'intérieur d'une fonction Python ont une portée locale. Et vous ne pouvez pas y accéder depuis l'extérieur de la fonction. Pour rendre la matrice produit C accessible de l'extérieur, nous devrons la déclarer en tant que variable globale. Ajoutez simplement le global qualificateur avant le nom de la variable.

Vérifiez si la multiplication matricielle est valide : Utilisez l'option shape attribut pour vérifier si A et B peuvent être multipliés. Pour tout tableau arr, arr.shape[0] et arr.shape[1] donner le nombre de lignes et Colonnes, respectivement. Alors if A.shape[1] == B.shape[0] vérifie si la multiplication matricielle est valide. Seulement si cette condition est True, la matrice produit sera calculée. Sinon, la fonction renvoie un message d'erreur.

Utilisez des boucles imbriquées pour calculer les valeurs : Pour calculer les éléments de la matrice résultante, nous devons parcourir les lignes de la matrice A, et l'extérieur for boucle fait cela. L'intérieur for boucle nous aide à parcourir la colonne de la matrice B. Et le plus profond for loop permet d'accéder à chaque élément de la colonne sélectionnée.

▶️ Maintenant que nous avons appris comment fonctionne la fonction Python pour multiplier les matrices, appelons la fonction avec les matrices A et B que nous avons générées précédemment.

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Comme la multiplication matricielle entre A et B est valide, la fonction multiply_matrix() renvoie la matrice produit C.

Use Python Nested List Comprehension to Multiply Matrices

Dans la section précédente, vous avez écrit une fonction Python pour multiplier des matrices. Maintenant, vous allez voir comment vous pouvez utiliser les compréhensions de listes imbriquées pour faire de même.

Voici la compréhension de liste imbriquée pour multiplier les matrices.

Au début, cela peut sembler compliqué. Mais nous allons analyser la compréhension de la liste imbriquée étape par étape.

Concentrons-nous sur une compréhension de liste à la fois et identifions ce qu'elle fait.

Nous utiliserons le modèle général suivant pour la compréhension de la liste :

[<do-this> for <item> in <iterable>]

where,
<do-this>: what you'd like to do—expression or operation
<item>: each item you'd like to perform the operation on
<iterable>: the iterable (list, tuple, etc.) that you're looping through

▶️ Consultez notre guide Compréhension de liste en Python - avec des exemples pour acquérir une compréhension approfondie.

Avant de poursuivre, veuillez noter que nous aimerions construire la matrice résultante C une rangée à la fois.

Compréhension des listes imbriquées expliquée

Étape 1 : Calculer une seule valeur dans la matrice C

Étant donné la ligne i de la matrice A et la colonne j de la matrice B, l'expression ci-dessous donne l'entrée à l'indice (i, j) dans la matrice C.

sum(a*b for a,b in zip(A_row, B_col)

# zip(A_row, B_col) returns an iterator of tuples
# If A_row = [a1, a2, a3] & B_col = [b1, b2, b3]
# zip(A_row, B_col) returns (a1, b1), (a2, b2), and so on

If i = j = 1, l'expression renverra l'entrée c_11 de la matrice C. Ainsi, vous pouvez obtenir un élément dans une ligne de cette façon.

Étape 2 : Construire une ligne dans la matrice C

Notre prochain objectif est de construire une ligne entière.

Pour la ligne 1 de la matrice A, vous devez parcourir toutes les colonnes de la matrice B pour obtenir une ligne complète dans la matrice C.

Revenez au modèle de compréhension de liste.

• remplacer <do-this> avec l'expression de l'étape 1, car c'est ce que vous voulez faire.
• Ensuite, remplacez <item> avec B_col—chaque colonne de la matrice B.
• Remplacez enfin <iterable> avec zip(*B)— la liste contenant toutes les colonnes de la matrice B.

Et voici la première liste de compréhension.

[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 

# zip(*B): * is the unzipping operator
# zip(*B) returns a list of columns in matrix B

Étape 3 : Construire toutes les lignes et obtenir la matrice C

Ensuite, vous devrez remplir la matrice produit C en calculant le reste des lignes.

Et pour cela, vous devez parcourir toutes les lignes de la matrice A.

Revenez encore une fois à la compréhension de la liste et procédez comme suit.

• remplacer <do-this> avec la compréhension de liste de l'étape 2. Rappelez-vous que nous avons calculé une ligne entière à l'étape précédente.
• Maintenant, remplacez <item> avec A_row— chaque ligne de la matrice A.
• Et ton <iterable> est la matrice A elle-même, lorsque vous parcourez ses lignes.

Et voici notre compréhension finale de la liste imbriquée.🎊

[[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A]

Il est temps de vérifier le résultat ! ✔

# cast into <a href="https://geekflare.com/numpy-reshape-arrays-in-python/">NumPy array</a> using np.array()
C = np.array([[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A])

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Si vous y regardez de plus près, cela équivaut aux boucles for imbriquées que nous avions précédemment, mais c'est plus succinct.

Vous pouvez également le faire d'autant plus efficacement en utilisant certaines fonctions intégrées. Découvrons-les dans la section suivante.

Use NumPy matmul() to Multiply Matrices in Python

La np.matmul() prend deux matrices en entrée et renvoie le produit si la multiplication matricielle entre les matrices d'entrée est Info de contact..

C = np.matmul(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Remarquez à quel point cette méthode est plus simple que les deux méthodes que nous avons apprises précédemment. En fait, au lieu de np.matmul(), vous pouvez utiliser un opérateur @ équivalent, et nous le verrons tout de suite.

Comment utiliser l'opérateur @ en Python pour multiplier les matrices

En Python, @ est un opérateur binaire utilisé pour la multiplication matricielle.

Il fonctionne sur deux matrices et, en général, sur des tableaux NumPy à N dimensions, et renvoie la matrice produit.

Remarque : Vous devez avoir Python 3.5 et versions ultérieures pour utiliser le @ opérateur.

Voici comment vous pouvez l'utiliser.

C = A@B
print(C)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Notez que la matrice produit C est la même que celle que nous avons obtenue précédemment.

Pouvez-vous utiliser np.dot() pour multiplier les matrices ?

Si vous avez déjà rencontré du code qui utilise np.dot() pour multiplier deux matrices, voici comment cela fonctionne.

C = np.dot(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Vous verrez que np.dot(A, B) renvoie également la matrice produit attendue.

Cependant, selon Documents NumPy, Tu devrais utiliser np.dot() uniquement pour calculer le produit scalaire de deux vecteurs unidimensionnels et non pour la multiplication matricielle.

Rappel de la section précédente, l'élément d'indice (i, j) de la matrice produit C est le produit scalaire de la ligne i de la matrice A et de la colonne j de la matrice B.

Comme NumPy diffuse implicitement cette opération de produit scalaire sur toutes les lignes et toutes les colonnes, vous obtenez la matrice de produit résultante. Mais pour garder votre code lisible et éviter toute ambiguïté, utilisez np.matmul() au sein de l’ @ opérateur à la place.

Conclusion

🎯 Dans ce tutoriel, vous avez appris ce qui suit.

• Condition pour que la multiplication matricielle soit valide : nombre de colonnes dans la matrice A = nombre de lignes dans la matrice B.
• Comment écrire une fonction Python personnalisée qui vérifie si la multiplication matricielle est valide et renvoie la matrice produit. Le corps de la fonction utilise des boucles for imbriquées.
• Ensuite, vous avez appris à utiliser les listes imbriquées pour multiplier les matrices. Elles sont plus succinctes que les boucles for mais sont sujettes à des problèmes de lisibilité.
• Enfin, vous avez appris à utiliser la fonction intégrée NumPy np.matmul() pour multiplier les matrices et comment c'est le plus efficace en termes de vitesse.
• Vous avez également pris connaissance de la @ opérateur pour multiplier deux matrices en Python.

Et cela conclut notre discussion sur la multiplication matricielle en Python. À l'étape suivante, apprenez à vérifier si un nombre est premier en Python. Ou résoudre intéressant problèmes sur les chaînes Python.

Bon apprentissage !🎉