La multiplication matricielle est une opération fondamentale en algèbre linéaire.
Nous l'utilisons généralement dans de nombreuses applications telles que le traitement d'images, l'apprentissage automatique et bien d'autres. NumPy est un package Python remarquable pour le calcul scientifique.
Cependant, dans cet article, nous examinerons différentes méthodes pour effectuer une multiplication matricielle en Python sans utiliser NumPy.
Nous utiliserons boucles imbriquées, la fonction intégrée map() et la compréhension de liste.
De plus, nous examinerons les avantages et les inconvénients de chaque stratégie, ainsi que le moment où appliquer chacune d'elles. Si vous débutez en algèbre linéaire et souhaitez en savoir plus sur la multiplication matricielle ; continuez à lire.
Où utilisons-nous la multiplication matricielle ?
La multiplication matricielle est utilisée dans infographie pour modifier les visuels 2D et 3D. Par exemple, vous pouvez faire pivoter, mettre à l'échelle et déplacer des objets à l'écran. Les matrices sont utilisées dans le traitement d'image pour représenter les images sous forme de tableaux de pixels. En outre, des matrices peuvent être utilisées pour effectuer des opérations telles que le filtrage d'images.
Nous utilisons également des matrices dans machine learning. Ils peuvent nous aider à représenter les données et les paramètres du modèle. Nous pouvons effectuer de nombreuses opérations, telles que le calcul de produits scalaires et de produits matriciels-vectoriels.
Certes, cette opération est également très avantageuse dans les opérations scientifiques. Nous pouvons l'utiliser en physique et en ingénierie pour décrire des quantités physiques. Par conséquent, nous pouvons opérer avec des vecteurs et des tenseurs.
Pourquoi nous ne pouvons pas choisir d'utiliser NumPy ?
Alors que NumPy est un Librairie Python, ce n'est pas toujours l'option idéale pour la multiplication matricielle. Nous pouvons ne pas choisir d'utiliser NumPy pour des raisons telles que la taille et la dépendance, l'apprentissage et les systèmes hérités.
L'utilisation des fonctions intégrées de Python ou le développement de code personnalisé peuvent être plus efficaces dans certains cas. Il est toutefois crucial de noter que NumPy est une bibliothèque solide. En outre, vous pouvez également l'utiliser pour la multiplication matricielle.
Voyons maintenant comment réaliser une multiplication matricielle sans NumPy.
Méthode des boucles imbriquées
La technique des boucles imbriquées utilise des boucles imbriquées pour exécuter la multiplication matricielle en Python. La fonction itère sur chaque élément de la matrice. Et, il les multiplie en utilisant une série de boucles imbriquées. La fonction renvoie le résultat, qui est stocké dans une nouvelle matrice.
Cette approche est simple à appréhender. Cependant, cela peut ne pas être aussi efficace que d'autres moyens, en particulier pour les matrices plus grandes. Pourtant, c'est un excellent choix pour vous si vous débutez dans l'algèbre linéaire.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Définissez la matrice de résultats sur des zéros.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Prenons un exemple de la façon de procéder. Vous pouvez simplement ajouter ces lignes de code ci-dessous pour tester cet exemple.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Avantages :
- Facile à comprendre.
- Idéal pour les débutants ou ceux qui recherchent une compréhension plus approfondie de la multiplication matricielle.
Désavantages:
- Pas aussi efficace que les techniques alternatives, en particulier pour les matrices plus grandes.
- Il n'est pas aussi lisible que les autres approches.
méthode de la fonction map()
La méthode de la fonction map() fournit une approche alternative pour effectuer la multiplication matricielle en Python. Dans cette approche, nous utilisons la fonction intégrée map(). Par conséquent, nous utilisons un outil de programmation fonctionnelle qui applique une fonction fournie à chaque élément itérable (liste, tuple, etc.). De plus, la fonction map() accepte deux paramètres, une fonction et un itérable. Et, il renvoie un itérateur qui applique la fonction à chaque élément itérable.
Dans cette approche, nous parcourons chaque membre de la matrice et effectuons la multiplication à l'aide de la fonction imbriquée map().
La fonction zip() est utilisée pour parcourir chaque élément des matrices en parallèle.
Enfin, la fonction sum() est utilisée pour additionner les résultats.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Maintenant, encore une fois, nous pouvons tester notre code avec un exemple.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
Avantages
- Plus efficace que l'approche des boucles empilées
- Il utilise la programmation fonctionnelle pour simplifier le code.
Inconvénients
- Certaines personnes qui ne sont pas familières avec la programmation fonctionnelle peuvent la trouver moins lisible.
- Elle est moins compréhensible que la technique des boucles imbriquées.
Liste méthode de compréhension
La compréhension de liste vous permet de générer une nouvelle liste en une seule ligne de code. Par conséquent, cela se fait en appliquant une expression à chaque membre d'une liste existante.
Dans cette approche, la multiplication est effectuée en itérant de manière répétée à travers chaque membre de la matrice. Nous utilisons la compréhension de liste en couches.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
Avantages
- Par rapport à la méthode de la fonction map(), plus courte et plus lisible.
Inconvénients
- Cela peut être moins efficace que d'utiliser la fonction map(), en particulier pour les grandes matrices.
- C'est plus difficile que l'approche des boucles imbriquées.
Conclusion
Dans cet article, nous avons examiné des alternatives à l'utilisation de NumPy lors de la multiplication de matrices en Python. Nous avons effectué une multiplication matricielle dans des boucles imbriquées, la fonction intégrée map() et la compréhension de liste.
La meilleure stratégie dépendra des besoins particuliers de votre projet.
Chacune des stratégies a ses propres avantages et inconvénients. Pour vous assurer que la fonction fonctionne correctement, il est judicieux d'ajouter des cas de test avec différentes dimensions et valeurs de matrice.
Vous devez également inclure des tests de performances pour comparer l'exécution de ces méthodes.
Soyez sympa! Laissez un commentaire