Initiation au calcul matriciel avec NumPy

Ce tutoriel présente les notions de base du calcul matriciel en Python en s’appuyant sur la bibliothèque NumPy et quelques outils de visualisation proposés par Matplotlib. Ces opérations constituent le socle de l’algèbre linéaire numérique, largement utilisée en data science, en apprentissage automatique, en simulation et en physique numérique.

Dans la continuité d’une première initiation consacrée au calcul vectoriel avec NumPy, nous aborderons : la représentation d’une matrice, les opérations élémentaires (addition, multiplication par un scalaire), le produit matriciel, la transposée, la matrice identité, le calcul du déterminant et de l’inverse, la résolution de systèmes linéaires, l’étude des valeurs propres ainsi que des techniques de visualisation (heatmap, transformations linéaires simples).

En algèbre linéaire, une matrice est un tableau rectangulaire de nombres disposés en lignes et en colonnes. Une matrice m×n possède m lignes et n colonnes.

II-A. Créer une matrice avec NumPy▲

>>> import numpy as np

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

>>> A.shape
(2, 3)

II-B. Accès aux éléments et slicing▲

>>> A[0,1]
2

# première ligne
>>> A[0]
array([1, 2, 3])

# première colonne (utiliser le slicing)
>>> A[:,0]
array([1, 4])

Voyons ensuite comment réaliser les opérations de base sur les matrices avec NumPy.

III-A. Addition et multiplication par un scalaire▲

>>> B = np.array([[10, 20, 30],
...               [40, 50, 60]])
>>> A + B
array([[11, 22, 33],
       [44, 55, 66]])

>>> 2 * A
array([[ 2,  4,  6],
       [ 8, 10, 12]])

III-B. Transposée▲

>>> A.T
array([[1, 4],
       [2, 5],
       [3, 6]])

III-C. Produit matriciel (dot)▲

Produit matriciel classique : si A est de taille (m×p) et B de taille (p×n), le produit A·B existe et donne une matrice (m×n).

En NumPy, on utilise np.dot(A, B) ou l'opérateur A @ B :

 

Sélectionnez

>>> B = np.array([[1, 0],
...               [0, 1],
...               [1, 1]])  # taille (3,2)
>>> A.shape, B.shape
((2, 3), (3, 2))

>>> A @ B
array([[ 4,  5],
       [10, 11]])

Attention aux dimensions : la compatibilité des tailles est essentielle.

III-D. Matrice identité et matrice zéro▲

>>> np.eye(3)   # identité 3x3
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

>>> np.zeros((2,3))
array([[0., 0., 0.],
       [0., 0., 0.]])

Nous allons découvrir dans cette section les bases de l’algèbre linéaire à l’aide de NumPy.

IV-A. Déterminant et inverse▲

>>> import numpy.linalg as la

>>> M = np.array([[2, 1],
...               [3, 4]])
>>> la.det(M)
5.0

>>> la.inv(M)
array([[ 0.8, -0.2],
       [-0.6,  0.4]])

IV-B. Rang, valeurs propres et vecteurs propres▲

>>> la.matrix_rank(M)
2

>>> vals, vecs = la.eig(np.array([[2, 0],
...                              [0, 3]]))
>>> vals
array([2., 3.])
>>> vecs
array([[1., 0.],
       [0., 1.]])

IV-C. Résolution d'un système linéaire▲

>>> A = np.array([[3, 1],
...               [1, 2]])
>>> b = np.array([9, 8])
>>> x = la.solve(A, b)
>>> x
array([2., 3.])

# vérification
>>> A @ x
array([9., 8.])

Dans cette section, nous allons montrer comment représenter visuellement ces matrices à l'aide de Matplotlib.

V-A. Afficher une matrice (heatmap)▲

Pour visualiser les valeurs d'une matrice, on peut utiliser plt.imshow() ou plt.pcolormesh() :

 

Sélectionnez

import numpy as np
import matplotlib.pyplot as plt

M = np.random.rand(10, 10)  # matrice 10x10
plt.figure(figsize=(6,5))
plt.title("Heatmap d'une matrice 10x10")
plt.imshow(M, origin='lower', aspect='auto')
plt.colorbar(label='valeur')
plt.show()

Lors de son exécution, le script affiche une Heat map (carte thermique) :

Cette visualisation est utile pour repérer patterns, diagonales dominantes, blocs, etc.

V-B. Transformation linéaire : application géométrique▲

Une matrice 2×2 définit une transformation du plan. On peut visualiser l'image d'une grille ou d'une forme simple :

 

Sélectionnez

import numpy as np
import matplotlib.pyplot as plt

# matrice de transformation
T = np.array([[1.5, 0.5],
              [0.2, 1.2]])

# grille de points
X, Y = np.meshgrid(np.linspace(-2,2,9), np.linspace(-2,2,9))
pts = np.vstack([X.ravel(), Y.ravel()])  # shape (2, N)

# application de la transformation
pts_T = T @ pts

plt.figure(figsize=(6,6))
plt.scatter(pts[0], pts[1], label='original', s=10)
plt.scatter(pts_T[0], pts_T[1], label='transformé', s=10)
# tracé des vecteurs d'origine vers image
for i in range(pts.shape[1]):
    plt.plot([pts[0,i], pts_T[0,i]], [pts[1,i], pts_T[1,i]], linewidth=0.5)
plt.legend()
plt.axis('equal')
plt.title("Transformation linéaire définie par T")
plt.show()

Le code affiche le graphique :

Cette technique illustre visuellement l'effet d'une matrice (dilatation, rotation, cisaillement).

Nous présentons pour terminer deux scripts complets servant d’exemples guidés de calcul matriciel en algèbre linéaire.

VI-1. Script : inverse et vérification▲

import numpy as np
import numpy.linalg as la

A = np.array([[4., 7.],
              [2., 6.]])

detA = la.det(A)
print("det(A) =", detA)

if abs(detA) > 1e-12:
    A_inv = la.inv(A)
    print("A @ A_inv =\n", np.round(A @ A_inv, 8))
else:
    print("Matrice singulière, pas d'inverse.")

det(A) = 10.000000000000002
A @ A_inv =
 [[ 1. -0.]
 [ 0.  1.]]

VI-2. Script : résolution d'un système et comparaison LLS▲

import numpy as np
import numpy.linalg as la

A = np.array([[1., 1.],
              [1., 2.],
              [1., 3.]])  # 3x2 (surdéterminé)
b = np.array([6., 9., 12.])

# solution par moindres carrés
x, residuals, rank, s = la.lstsq(A, b, rcond=None)
print("Solution LLS x =", x)
print("Résidus :", residuals)

# Si A carrée, on utiliserait la.solve(A,b)

Solution LLS x = [3. 3.]
Résidus : [7.88860905e-31]

• Privilégier les routines de la bibliothèque (numpy.linalg.solve, numpy.linalg.lstsq, numpy.linalg.eig) plutôt que d'implémenter soi-même la résolution pour des raisons de robustesse et de performance.
• Utilisez les opérations vectorisées NumPy plutôt que des boucles Python. Cela rend le code plus concis, plus lisible et souvent beaucoup plus rapide.
• Attention à la condition numérique : une matrice mal conditionnée amplifie les erreurs de calcul — vérifier numpy.linalg.cond(A).
• Pour de grandes matrices creuses (contenant beaucoup de zéros), utiliser scipy.sparse et les algorithmes conçus pour matrices creuses.

Nous avons passé en revue les opérations fondamentales du calcul matriciel avec NumPy et montré comment les appliquer à des problèmes concrets : inversion de matrices, résolution de systèmes, calcul des valeurs propres et visualisation.

Ce tutoriel s’inscrit comme une suite naturelle de l’introduction au calcul vectoriel (manipulation et visualisation). Pour approfondir et mieux comprendre la correspondance entre vecteurs et matrices, vous pouvez vous référer à l’article initial, qui propose de nombreux exemples pratiques.

Module compresséfichier de test contenant les scripts fournis en exemples dans le corps de l'article.

Je tiens à remercier ... pour ses différentes suggestions, ainsi que pour sa relecture.

Sources et lectures recommandées

• NumPy — linear algebra (linalg)
• Matplotlib — guide d'utilisation
• Algèbre linéaire
• Heat map (carte thermique)