Les images sont des matrices

Une image en niveaux de gris est essentiellement un tableau NumPy bidimensionnel. Lorsque vous transposez, retournez, recadrez ou convoluez la matrice, l’image change en conséquence.

Après avoir terminé ce cas, vous comprendrez :Le fondement du traitement d’image est l’algèbre linéaire ; une matrice n’est qu’un tableau de nombres.


Introduction quotidienne

Grille de pixels d’une photo

Zoomez sur une photo sur votre téléphone, puis zoomez encore — jusqu’à ce que vous puissiez voir de minuscules carrés. Chaque carré n’a qu’une seule valeur de couleur : 0 signifie noir pur, 255 signifie blanc pur, et les nombres intermédiaires sont différentes nuances de gris.

La photo entière est un tableau rectangulaire de ces minuscules carrés — les mathématiciens appellent cela une "matrice」。


Compréhension intuitive

Une matrice n’est pas un concept mystérieux — c’est simplement un tableau rempli de nombres.

Par exemple, dans la matrice \(3 \times 3\) ci-dessous, chaque nombre représente la luminosité d’un pixel (0 est le plus sombre, 1 est le plus lumineux) :

Image en niveaux de gris 3x3 Une matrice, 9 nombres
\[ M = \begin{bmatrix} 0.0 & 0.5 & 1.0 \\ 0.3 & 0.7 & 0.6 \\ 0.8 & 0.2 & 0.4 \end{bmatrix} \]

Avec cette compréhension, les différentes opérations de traitement d'image deviennent claires :

Transposée
img.T
Retournement selon la diagonale
Miroir horizontal
img[:, ::-1]
Retournement gauche-droite
Miroir vertical
img[::-1, :]
Retournement haut-bas
Recadrage
img[10:54, 10:54]
Extraire une sous-région
Flou
Noyau de convolution à moyenne glissante
Moyenne de voisinage
Rotation
Transformation de coordonnées
Multiplication matricielle

Lorsque vous cliquez sur un bouton dans Photoshop, en coulisses, NumPy opère sur un tableau bidimensionnel.


Définition mathématique

Une image en niveaux de gris \(H \times W\) peut être représentée comme une matrice à valeurs réelles :

\[ M \in \mathbb{R}^{H \times W}, \quad M_{ij} \in [0, 1] \]

où \(M_{ij}\) représente la valeur de luminosité du pixel à la \(i\)-ième ligne et à la \(j\)-ième colonne.

Concepts clés des opérations matricielles :

OpérationExpression mathématiqueSyntaxe NumPyEffet d’image
Transposée\(M^T_{ij} = M_{ji}\)img.TPermuter les lignes et les colonnes, retourner le long de la diagonale
Retournement horizontal\(M'_{ij} = M_{i, W-1-j}\)img[:, ::-1]Inverser les indices de colonne
Retournement vertical\(M'_{ij} = M_{H-1-i, j}\)img[::-1, :]Inversion de l’indice de ligne
Flou moyen\(M'_{ij} = \frac{1}{k^2}\sum_{p,q} M_{i+p, j+q}\)Fenêtre glissante pour calculer mean()Remplacer chaque pixel par la moyenne du voisinage

L'opération de « fenêtre glissante » utilisée dans le flou par moyenne est essentiellementconvolutionson prototype — l'opération centrale des réseaux de neurones convolutionnels (CNN).


Exercice pratique Python

Générer une image synthétique en niveaux de gris, et utiliser les opérations sur les tableaux NumPy pour implémenter la transposition, le retournement, le recadrage et un flou par convolution écrit à la main.

Exemple

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import os

# Créer le répertoire de sortie
OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "outputs")
os.makedirs(OUT, exist_ok=True)

# 1. Générer une image en niveaux de gris synthétique : dégradé diagonal + carré lumineux au milieu
size = 64
img = np.zeros((size, size))
for i in range(size):
    for j in range(size):
        img[i, j] = (i + j) / (2 * size)  # Dégradé diagonal du sombre au clair
img[20:44, 20:44] += 0.6                  # Ajouter un carré lumineux au milieu
img = np.clip(img, 0, 1)                  # Limiter à l'intervalle [0, 1]

print("EXEMPLE dimensions de la matrice d'image :, img.shape)
print("Première partie 3x3 de la matrice d'image :\n", np.round(img[:3, :3], 3))

# 2. Opérations matricielles = transformations d'image
img_transpose = img.T           # Transposition : permuter les lignes et les colonnes
img_flip_lr = img[:, ::-1]      # Miroir horizontal : inverser les indices de colonnes
img_flip_ud = img[::-1, :]      # Miroir vertical : inverser les indices de lignes
img_crop = img[10:54, 10:54]    # Recadrage : découper pour obtenir une sous-matrice

# 3. Flou moyen écrit à la main (noyau de convolution 5x5, sans OpenCV)
def box_blur(mat, k=5):
    """Appliquer un flou moyen à la matrice en utilisant une fenêtre glissante k x k"""
    pad = k // 2
    # Compléter la bordure avec les valeurs des bords (remplissage de bord)
    padded = np.pad(mat, pad, mode="edge")
    out = np.zeros_like(mat)
    for i in range(mat.shape[0]):
        for j in range(mat.shape[1]):
            # Prendre le voisinage k x k et calculer la moyenne
            out[i, j] = padded[i:i+k, j:j+k].mean()
    return out

img_blur = box_blur(img, k=5)
print("EXEMPLE première partie 3x3 de la matrice floutée :\n",
      np.round(img_blur[:3, :3], 3))

# 4. Enregistrer la figure de comparaison visuelle
fig, axes = plt.subplots(2, 3, figsize=(12, 8))
titles = ["Image originale (matrice)", "Transposition img.T",
          "Miroir horizontal img[:, ::-1]",
          "Miroir vertical img[::-1, :]",
          "Recadrage img[10:54, 10:54]",
          "Flou moyen (convolution 5x5)"]
images = [img, img_transpose, img_flip_lr,
          img_flip_ud, img_crop, img_blur]

for ax, title, im in zip(axes.flat, titles, images):
    ax.imshow(im, cmap="gray", vmin=0, vmax=1)
    ax.set_title(title, fontsize=11)
    ax.axis("off")

plt.tight_layout()
plt.savefig(os.path.join(OUT, "01_image_as_matrix.png"), dpi=130)
print(f"\nEXEMPLE résultat de visualisation enregistré dans {OUT}/01_image_as_matrix.png")
EXAMPLE 图像矩阵形状 (shape): (64, 64)
图像矩阵前 3x3 部分:
 [[0.    0.008 0.016]
 [0.008 0.016 0.023]
 [0.016 0.023 0.031]]
EXAMPLE 模糊后矩阵前 3x3 部分:
 [[0.009 0.011 0.013]
 [0.01  0.013 0.016]
 [0.011 0.016 0.021]]
EXAMPLE 可视化结果已保存到 .../outputs/01_image_as_matrix.png

Comme vous pouvez le voir, après le flou, les différences numériques entre pixels adjacents deviennent plus petites — c'est précisément l'essence mathématique du "flou" :Remplacer la valeur de pixel d'origine par la moyenne du voisinage。


Scénarios d'application en IA

Scénario d'IAComment utiliser les matrices
Réseau de neurones convolutif (CNN)L'entrée est un tenseur d'ordre 4 composé d'un lot d'images (batch, H, W, C), et chaque couche fait glisser un noyau de convolution (petite matrice) sur l'entrée
Augmentation de donnéesPendant l'entraînement, retournez, faites pivoter et recadrez les images de manière aléatoire — toutes sont des opérations matricielles, utilisées pour augmenter l'ensemble d'entraînement.
Prétraitement des imagesAvant de les fournir au modèle, recadrez uniformément à une taille fixe (par ex., 224x224) — c'est-à-dire un découpage et une mise à l'échelle de matrices.
Transfert de styleReprésentez l'image sous forme de matrice de caractéristiques, et modifiez les caractéristiques de "style" au moyen d'opérations matricielles.

ndarray dans NumPy et Tensor dans PyTorch sont essentiellement la même chose : une table numérique multidimensionnelle. Comprendre la matrice signifie comprendre la structure de données la plus élémentaire des frameworks d'apprentissage profond.

Autres extensions