Comment calculer l’inverse d’une matrice en Python avec NumPy ?

Introduction

Lorsqu’on travaille avec l’analyse de données, l’apprentissage automatique (machine learning) ou le calcul scientifique, on rencontre souvent des situations où il est nécessaire d’inverser une matrice — en particulier pour résoudre des systèmes d’équations linéaires ou effectuer des transformations.

La bibliothèque NumPy de Python rend ce processus à la fois rapide et simple.

Qu’est-ce que l’inverse d’une matrice ?

Pour une matrice carrée $( A )$, la matrice inverse $( A^{-1} )$ est définie de telle sorte que :

\begin{equation}
[
A \times A^{-1} = I
]
\end{equation}

où ( I ) est la matrice identité (une matrice contenant des 1 sur la diagonale et des 0 ailleurs).

Cependant, toutes les matrices ne sont pas inversibles.
Une matrice est dite inversible (ou non singulière) si et seulement si son déterminant est non nul.

Étape par étape : calculer l’inverse d’une matrice en Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Étape 1 — Importer NumPy
import numpy as np

# Étape 2 — Définir une matrice carrée
A = np.array([[4, 7],
              [2, 6]])

# Étape 3 — Calculer l’inverse
A_inv = np.linalg.inv(A)
print("Inverse de A :")
print(A_inv)

Sortie :

1
2
3

Inverse de A :
[[ 0.6 -0.7]
 [-0.2  0.4]]

Vérifier le résultat

Vous pouvez vérifier le résultat en multipliant la matrice d’origine par son inverse.
Le produit doit être (approximativement) la matrice identité.

1
2
3

I = A @ A_inv
print("\nA * A_inv =")
print(np.round(I, 3))

Résultat :

1
2
3

A * A_inv =
[[1. 0.]
 [0. 1.]]

Les petites différences (par exemple 0.999 au lieu de 1.0) sont dues à la précision numérique des calculs en virgule flottante.

Vérifier si une matrice est inversible

Avant de calculer l’inverse, il est recommandé de vérifier le déterminant :

1
2
3
4
5

det = np.linalg.det(A)
print("Déterminant de A :", det)

if det == 0:
    print("La matrice est singulière — aucun inverse n’existe.")

Si le déterminant est nul, la matrice n’est pas inversible.

Gérer les matrices non inversibles

Si votre matrice peut être singulière ou non carrée, vous pouvez tout de même calculer une pseudo-inverse à l’aide de :

1

A_pinv = np.linalg.pinv(A)

La pseudo-inverse de Moore–Penrose fonctionne même lorsque la véritable inverse n’existe pas.
Elle est largement utilisée en apprentissage automatique et en régression aux moindres carrés.

Résumé

Un autre exemple

Pour calculer l’inverse d’une matrice en Python, une solution consiste à utiliser les fonctions d’algèbre linéaire de NumPy via le module linalg.

Exemple

\begin{equation}
A = \left( \begin{array}{ccc}
1 & 3 & 3 \\
1 & 4 & 3 \\
1 & 3 & 4
\end{array}\right)
\end{equation}

L’inverse de ( A ) est :

\begin{equation}
A^{-1} = \left( \begin{array}{ccc}
7 & -3 & -3 \\
-1 & 1 & 0 \\
-1 & 0 & 1
\end{array}\right)
\end{equation}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

>>> import numpy as np
>>> A = np.array([[1, 3, 3],
...                [1, 4, 3],
...                [1, 3, 4]])
>>> A
array([[1, 3, 3],
       [1, 4, 3],
       [1, 3, 4]])

>>> A_inv = np.linalg.inv(A)
>>> A_inv
array([[ 7., -3., -3.],
       [-1.,  1.,  0.],
       [-1.,  0.,  1.]])

Vérification du résultat

1
2
3
4

>>> A_inv.dot(A)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Comme prévu, la multiplication de ( A^{-1} ) par ( A ) donne la matrice identité, confirmant que l’inversion est correcte.

Références