NumPy Matrix Operations

1. La Multiplication de Matrices (Produit Scalaire)

En NumPy, il est essentiel de distinguer deux types de multiplication :

1. La multiplication élément par élément (element-wise) : C'est ce qui se passe lorsque vous utilisez l'opérateur * entre deux tableaux de même forme. Chaque élément du premier tableau est multiplié par l'élément correspondant dans le second.
2. La multiplication de matrices (produit matriciel ou "dot product") : C'est l'opération d'algèbre linéaire que vous connaissez. Pour que cette opération soit possible, le nombre de colonnes de la première matrice doit être égal au nombre de lignes de la seconde. Une matrice de taille $m\times n$ multipliée par une matrice de taille $n\times p$ donnera une matrice de taille $m\times p$.

En Python moderne (3.5+) et NumPy, l'opérateur de choix pour la multiplication de matrices est @. La fonction np.matmul() fait la même chose.

L'image suivante illustre le calcul de chaque élément de la matrice résultante.

Voyons comment cela fonctionne en pratique.

import numpy as np




# Matrice A (2x3)
A = np.array([[1, 2, 3],
              [4, 5, 6]])




# Matrice B (3x2)
B = np.array([[7, 8],
              [9, 10],
              [11, 12]])




# Multiplication élément par élément (ne fonctionnera pas car les formes sont différentes)
# A * B -> ValueError




# Multiplication de matrices (Produit Scalaire)
C = A @ B  # Utilisation de l'opérateur @



# ou C = np.matmul(A, B)

print("Matrice A (shape", A.shape, "):\n", A)
print("\nMatrice B (shape", B.shape, "):\n", B)
print("\nRésultat de A @ B (shape", C.shape, "):\n", C)

Le résultat sera :

Matrice A (shape (2, 3) ):
 [[1 2 3]
 [4 5 6]]

Matrice B (shape (3, 2) ):
 [[ 7  8]
 [ 9 10]
 [11 12]]

Résultat de A @ B (shape (2, 2) ):
 [[ 58  64]
 [139 154]]

Le premier élément C[0,0] (valeur 58) est calculé comme suit : (1*7) + (2*9) + (3*11) = 7 + 18 + 33 = 58.

Pour une explication plus formelle de la multiplication de matrices et de son implémentation en NumPy, consultez la section suivante.

2. La Transposée d'une Matrice

La transposée d'une matrice est une opération qui "retourne" la matrice le long de sa diagonale principale. Concrètement, les lignes deviennent des colonnes et les colonnes deviennent des lignes. Si une matrice $A$ a une forme $m\times n$, sa transposée $A^T$ aura une forme $n\times m$.

En NumPy, le moyen le plus simple d'obtenir la transposée est d'utiliser l'attribut .T.

A = np.array([[1, 2, 3],
              [4, 5, 6]])




# Calculer la transposée
A_transpose = A.T

print("Matrice A (shape", A.shape, "):\n", A)
print("\nTransposée de A (shape", A_transpose.shape, "):\n", A_transpose)

Le résultat est :

Matrice A (shape (2, 3) ):
 [[1 2 3]
 [4 5 6]]

Transposée de A (shape (3, 2) ):
 [[1 4]
 [2 5]
 [3 6]]

Attention : L'application de .T à un tableau 1D n'a aucun effet, car il n'a pas de "deuxième dimension" à pivoter. C'est une source d'erreur courante. Pour transposer un vecteur, il doit d'abord être défini comme une matrice ligne ou une matrice colonne (c'est-à-dire un tableau 2D).

vecteur_1d = np.array([1, 2, 3])
print("Vecteur 1D shape:", vecteur_1d.shape) # (3,)
print("Transposée 1D shape:", vecteur_1d.T.shape) # (3,) - inchangé

vecteur_ligne = np.array([[1, 2, 3]]) # Tableau 2D
print("\nVecteur ligne shape:", vecteur_ligne.shape) # (1, 3)
print("Transposée (vecteur colonne) shape:", vecteur_ligne.T.shape) # (3, 1)

La lecture suivante formalise cette opération.

3. L'Inverse d'une Matrice

Tout comme le nombre $\frac{1}{5}$ est l'inverse de 5 car $5\times \frac{1}{5}=1$, l'inverse d'une matrice $A$, notée $A^{-1}$, est la matrice qui, multipliée par $A$, donne la matrice identité $I$.

La matrice identité est une matrice carrée avec des 1 sur la diagonale principale et des 0 partout ailleurs. Elle est l'équivalent du nombre 1 dans le monde des matrices.

Cependant, toutes les matrices n'ont pas d'inverse. Pour qu'une matrice soit inversible, elle doit satisfaire deux conditions :

1. Elle doit être carrée (avoir le même nombre de lignes et de colonnes).
2. Son déterminant doit être non nul. Une matrice dont le déterminant est nul est dite singulière.

En NumPy, les opérations d'algèbre linéaire plus avancées se trouvent dans le sous-module np.linalg. Pour calculer l'inverse, on utilise np.linalg.inv().

# Matrice A (carrée et non-singulière)
A = np.array([[2, 1],
              [4, 3]])




# Calculer l'inverse
A_inv = np.linalg.inv(A)

print("Matrice A:\n", A)
print("\nInverse de A:\n", A_inv)




# Vérifions que A @ A_inv donne la matrice identité
identite = A @ A_inv
print("\nVérification (A @ A_inv):\n", np.round(identite)) # On arrondit pour gérer les petites erreurs de précision

Résultat :

Matrice A:
 [[2 1]
 [4 3]]

Inverse de A:
 [[ 1.5 -0.5]
 [-2.   1. ]]

Vérification (A @ A_inv):
 [[1. 0.]
 [0. 1.]]

Si nous essayons d'inverser une matrice singulière, NumPy lèvera une erreur.

# Matrice singulière (colonne 2 = 2 * colonne 1)
B = np.array([[1, 2],
              [3, 6]])




# Ceci va provoquer une erreur : LinAlgError: Singular matrix
# np.linalg.inv(B)

Pour une description détaillée de l'inverse et des conditions de son existence, lisez la section suivante.

Une note sur la pseudo-inverse

Que faire si une matrice n'est pas carrée, ce qui est très courant pour les ensembles de données en machine learning ? Dans ce cas, l'inverse "vrai" n'existe pas. Cependant, il existe un concept très utile appelé pseudo-inverse, qui généralise l'idée d'inversion. Elle est au cœur de la résolution de nombreux problèmes, notamment la régression linéaire.

La vidéo suivante explique de manière très intuitive l'utilité de la pseudo-inverse et comment elle permet de résoudre un problème de régression linéaire de A à Z en quelques lignes de NumPy.

Exercice Pratique : Résolution d'un système d'équations

L'une des applications les plus directes de l'inverse d'une matrice est la résolution de systèmes d'équations linéaires. Un système comme :

peut s'écrire sous forme matricielle $A\mathbf{x}=\mathbf{b}$, où :

La solution est donnée par $\mathbf{x}=A^{-1}\mathbf{b}$.

Votre tâche : utilisez NumPy pour trouver les valeurs de $x$ et $y$.

Solution

import numpy as np




# Définir la matrice A et le vecteur b
A = np.array([[2, 1],
              [4, 3]])

b = np.array([[8],
              [18]])




# 1. Calculer l'inverse de A
A_inv = np.linalg.inv(A)




# 2. Calculer la solution x = A_inv @ b
x = A_inv @ b

print("La solution du système est (x, y) :")
print(x)



# Devrait afficher [[3.], [2.]], donc x=3 et y=2.

Conclusion

Félicitations ! Vous avez franchi une étape importante en passant des concepts d'algèbre linéaire à leur implémentation pratique en code. Ces opérations sont des briques de construction que vous utiliserez constamment.

Points clés à retenir :

• Le produit matriciel se fait avec l'opérateur @ ou np.matmul(), et il est différent de la multiplication élément par élément (*).
• La transposée d'une matrice s'obtient facilement avec l'attribut .T.
• L'inverse d'une matrice carrée non singulière se calcule avec np.linalg.inv().
• Ces opérations sont stockées dans le module np.linalg pour les plus complexes comme l'inverse.
• Des concepts comme la pseudo-inverse ont des applications directes et puissantes en machine learning.

Dans la prochaine leçon, nous reviendrons à la manipulation de tableaux NumPy. Vous apprendrez à remodeler un tableau NumPy dans une nouvelle forme compatible, une autre compétence essentielle pour préparer les données avant de les fournir à des algorithmes de machine learning.