— factory / algos ML / vision par ordinateur

RÉSEAU DE NEURONES CONVOLUTIF (CNN).

Un réseau de neurones fait pour les images : de petits filtres glissent sur l'image et repèrent des motifs locaux, bords, courbes, puis formes, quel que soit leur emplacement. C'est la base de la vision par ordinateur en entreprise : lecture de documents, contrôle qualité, tri de photos, imagerie médicale.

ImagesClassificationDeep learningVisionNiveau : intermédiaire

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceLa référence historique en vision, très fiable sur des images

InterprétabilitéLes filtres se visualisent, la décision reste opaque

VitesseRapide en prédiction, entraînement lourd sur de vraies photos

Facilité de réglageArchitecture et augmentation de données à choisir

Tolérance aux données brutesTolère décalages et petites déformations de l'image

EN 30 SECONDES

Une loupe qu'on promène sur un document. À chaque position, on se demande : y a-t-il ici un trait vertical, une boucle, un angle ? La carte des réponses dit ce qui est écrit, où que ce soit sur la page.

1. Des filtres qui glissent

Un filtre est une petite grille de poids (3 × 3 pixels). Il parcourt toute l'image et s'active là où il reconnaît son motif. Le même filtre sert partout : c'est ce qui rend le CNN économe en paramètres.

2. Le pooling résume

On garde la valeur la plus forte de chaque zone de 2 × 2. L'image rétrécit, le réseau devient tolérant aux petits décalages.

3. Des motifs de plus en plus riches

Les premières couches voient des bords, les suivantes combinent ces bords en boucles et en angles, puis en chiffres entiers ou en objets.

4. Une couche finale décide

Les cartes de motifs sont aplaties et passées à une couche dense qui donne une probabilité par classe.

LE CAS MÉTIER

banque · lecture de chèques / bordereaux / bons de livraison

EN ENTRÉE

Des chiffres manuscrits en image

1 797 chiffres scannés en 8 × 8 pixels. Le CNN les lit comme des images, en tenant compte des pixels voisins, et non comme une liste de 64 nombres indépendants.

EN SORTIE

Le chiffre lu et sa probabilité

Pour chaque case d'un chèque ou d'un bordereau, le chiffre le plus probable. Sous un seuil de confiance fixé avec le métier, la case part en saisie manuelle.

CE QU'ON MESURE

L'exactitude, puis le taux de reprise

L'exactitude sur des images jamais vues mesure la lecture. Le vrai indicateur métier est le taux de reprise manuelle à un taux d'erreur accepté : combien de documents passent sans intervention humaine.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Images et documents scannés : lecture de caractères, tri, contrôle qualité visuel
Motif recherché qui peut apparaître n'importe où dans l'image
Signaux avec une structure locale : spectrogrammes audio, courbes de vibration
Base de quelques milliers d'images étiquetées, ou modèle pré-entraîné à adapter

NON

Données tabulaires (clients, contrats) : il n'y a pas de voisinage entre colonnes, utiliser un boosting
Très peu d'images étiquetées : partir d'un réseau pré-entraîné (ResNet) plutôt que de zéro
Localiser ou compter plusieurs objets dans l'image : c'est de la détection, voir YOLO
Découper l'image pixel par pixel : c'est de la segmentation, voir U-Net

LES 4 RÉGLAGES QUI COMPTENT

Noms donnés pour R (keras3) et Python (Keras), identiques à la syntaxe près.

filters

Le nombre de filtres par couche. On double souvent à chaque étage (32, 64, 128) pendant que l'image rétrécit.

kernel_size

La taille du filtre. 3 × 3 est le standard : deux couches 3 × 3 voient aussi loin qu'un filtre 5 × 5, avec moins de paramètres.

pooling / strides

La réduction de l'image entre deux étages. Trop tôt ou trop fort sur une petite image, on perd l'information : ici un seul pooling sur 8 × 8 pixels.

Augmentation de données

Rotations légères, décalages, variations de contraste appliqués aux images d'entraînement. Le moyen le plus efficace de gagner en robustesse sans étiqueter plus.

LE CODE MINIMAL

jeu d'exemple : chiffres_manuscrits.csv ↓

# Chèques et bordereaux manuscrits : CNN en R (keras3)
library(keras3)

chiffres <- read.csv("chiffres_manuscrits.csv")
# Chaque ligne redevient une image 8 x 8 à un canal (ordre ligne par ligne)
X <- array_reshape(as.matrix(chiffres[, 1:64]) / 16, c(nrow(chiffres), 8, 8, 1))
y <- chiffres$chiffre
set.seed(42)
idx <- sample(nrow(chiffres), round(0.7 * nrow(chiffres)))

set_random_seed(42)
cnn <- keras_model_sequential(input_shape = c(8, 8, 1))
cnn <- layer_conv_2d(cnn, filters = 32, kernel_size = 3, padding = "same", activation = "relu")  # 32 filtres 3 x 3
cnn <- layer_max_pooling_2d(cnn, pool_size = 2)          # garde le signal le plus fort de chaque zone 2 x 2
cnn <- layer_conv_2d(cnn, filters = 64, kernel_size = 3, padding = "same", activation = "relu")
cnn <- layer_flatten(cnn)
cnn <- layer_dense(cnn, units = 10, activation = "softmax")
compile(cnn, optimizer = "adam", loss = "sparse_categorical_crossentropy", metrics = "accuracy")
fit(cnn, X[idx, , , , drop = FALSE], y[idx], epochs = 30, batch_size = 32, validation_split = 0.1, verbose = 0)

resultat <- evaluate(cnn, X[-idx, , , , drop = FALSE], y[-idx], verbose = 0)
cat("Exactitude test :", round(resultat[["accuracy"]], 3), "\n")
cat("Paramètres du réseau :", count_params(cnn), "\n")

# Chèques et bordereaux manuscrits : CNN en Python (Keras)
import pandas as pd
import keras
from keras import layers
from sklearn.model_selection import train_test_split

chiffres = pd.read_csv("chiffres_manuscrits.csv")
# Chaque ligne redevient une image 8 x 8 à un canal
X = (chiffres.drop(columns="chiffre").values / 16).reshape(-1, 8, 8, 1).astype("float32")
y = chiffres["chiffre"].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

keras.utils.set_random_seed(42)
cnn = keras.Sequential([
    keras.Input((8, 8, 1)),
    layers.Conv2D(32, 3, padding="same", activation="relu"),   # 32 filtres 3 x 3 qui glissent sur l'image
    layers.MaxPooling2D(2),                                    # garde le signal le plus fort de chaque zone 2 x 2
    layers.Conv2D(64, 3, padding="same", activation="relu"),
    layers.Flatten(),
    layers.Dense(10, activation="softmax"),
])
cnn.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
cnn.fit(X_train, y_train, epochs=30, batch_size=32, validation_split=0.1, verbose=0)

perte, exactitude = cnn.evaluate(X_test, y_test, verbose=0)
print("Exactitude test :", round(exactitude, 3))
print("Paramètres du réseau :", cnn.count_params())

QUESTIONS FRÉQUENTES

Qu'est-ce qu'une convolution dans un CNN ?

C'est l'opération qui fait glisser un petit filtre sur l'image. À chaque position, on multiplie les pixels par les poids du filtre et on additionne. Le résultat est une carte qui indique où le motif du filtre est présent. Les poids des filtres sont appris pendant l'entraînement.

Quelle différence entre CNN et réseau de neurones classique ?

Un réseau classique (MLP) relie chaque pixel à chaque neurone et ignore qui est voisin de qui. Le CNN exploite la proximité des pixels et réutilise les mêmes filtres partout. Il a beaucoup moins de paramètres à taille d'image égale et reconnaît un motif où qu'il se trouve.

Combien d'images faut-il pour entraîner un CNN ?

De zéro, quelques milliers d'images par classe sont un minimum courant sur de vraies photos. En partant d'un réseau pré-entraîné sur ImageNet, quelques centaines d'images par classe suffisent souvent. C'est la démarche la plus fréquente en entreprise.