SOM (Self-Organizing Maps) : Guide complet — Principes, Exemples et Implémentation Python

Résumé

Les Self-Organizing Maps (SOM), également appelées cartes de Kohonen du nom de leur inventeur Teuvo Kohonen (1982), constituent l’un des algorithmes d’apprentissage non supervisé les plus élégants jamais conçus. Contrairement aux méthodes classiques de réduction de dimensionalité comme l’ACP, les SOM préservent la topologie des données : deux échantillons proches dans l’espace d’origine se retrouvent voisins sur la carte bidimensionnelle. Cette propriété unique fait des SOM un outil de choix pour la visualisation, l’exploration et la segmentation de jeux de données complexes.

Dans ce guide, nous explorerons le principe mathématique des SOM, leur intuition profonde, une implémentation Python complète avec MiniSom, les hyperparamètres à maîtriser, ainsi que quatre cas d’usage concrets.

Principe mathématique des cartes auto-organisées

Une carte de Kohonen est un réseau de neurones artificiels organisé sur une grille régulière (généralement 1D ou 2D). Chaque neurone i possède un vecteur de poids w_i de même dimension que les données d’entrée. L’algorithme repose sur un mécanisme d’apprentissage compétitif où les neurones entrent en compétition pour représenter chaque échantillon.

Étape 1 : Initialisation aléatoire des poids

Au démarrage, les vecteurs de poids de tous les neurones sont initialisés aléatoirement :

∀i : w_i(0) ∼ uniforme(0, 1)  ou  échantillonnés parmi les données

L’initialisation par échantillonnage parmi les données réelles donne souvent de meilleurs résultats que l’initialisation purement aléatoire, car elle place les poids directement dans le domaine des données observées.

Étape 2 : Recherche du BMU (Best Matching Unit)

Pour chaque vecteur d’entrée x présenté au réseau, on identifie le neurone vainqueur — le BMU — c’est-à-dire le neurone dont le vecteur de poids est le plus proche de x selon une métrique de distance (généralement la distance euclidienne) :

BMU(x) = argmin_i ||x - w_i(t)||

Le BMU est le neurone qui « ressemble le plus » à la donnée x présentée. Toute la carte réagit, mais c’est le BMU qui est le plus fortement sollicité.

Étape 3 : Mise à jour des poids — la règle de Kohonen

Une fois le BMU identifié, les poids de tous les neurones de la grille sont ajustés selon la formule suivante :

w_i(t+1) = w_i(t) + α(t) · h(i, BMU, t) · (x - w_i(t))

Cette équation est au cœur du fonctionnement des SOM. Décortiquons chaque terme :

• α(t) : le taux d’apprentissage (learning rate), qui décroît avec le temps. Il contrôle l’amplitude des modifications.
• h(i, BMU, t) : la fonction de voisinage (neighborhood function), typiquement une gaussienne centrée sur le BMU. Elle détermine l’influence spatiale du BMU sur ses voisins sur la grille.
• (x – w_i(t)) : le vecteur d’écart entre la donnée et le poids actuel, qui indique la direction de la correction.

Fonction de voisinage

La fonction de voisinage la plus courante est une gaussienne :

h(i, BMU, t) = exp(-||r_i - r_BMU||² / (2σ(t)²))

où r_i et r_BMU sont les positions des neurones sur la grille, et σ(t) est le rayon de voisinage qui décroît au fil des itérations.

Deux variantes existent :

• Voisinage gaussien (soft) : influence progressive, tous les neurones reçoivent une mise à jour.
• Voisinage à bulle (hard) : seuls les neurones dans un rayon σ autour du BMU sont mis à jour.

Décroissance du taux d’apprentissage et du rayon de voisinage

Contrairement à de nombreux algorithmes d’apprentissage, les SOM utilisent une phase d’ordonnancement progressif :

α(t) = α_0 · exp(-t / n_iterations)
σ(t) = σ_0 · exp(-t / n_iterations)

Au début, le taux d’apprentissage et le rayon de voisinage sont élevés : la carte s’organise globalement, formant les grandes structures. Progressivement, ces deux paramètres décroissent, permettant à la carte d’affiner localement les positions des neurones. Cette double décroissance est essentielle : sans elle, la carte ne parviendrait jamais à converger vers une organisation stable.

Intuition : une salle d’étudiants qui s’auto-organise

Imaginez un amphithéâtre dans lequel des centaines d’étudiants entrent en désordre. On leur demande de se placer spontanément selon leur domaine d’études — mais sans parler, sans se coordonner, simplement en observant leurs voisins et en se rapprochant de ceux qui leur ressemblent.

Ce qui se produit est remarquable. Les mathématiciens se rassemblent naturellement dans un coin. Les littéraires s’installent dans un autre coin. Les informaticiens se positionnent entre les deux — car leur domaine emprunte aux mathématiques autant qu’aux sciences humaines. Les physiciens se retrouvent près des mathématiciens, avec quelques biologistes à la frontière. Les philosophes s’installent près des littéraires.

Les transitions entre domaines voisins sont douces et naturelles. Il n’y a pas de coupure nette : entre mathématiques et informatique, il y aura une zone de « mathématiques appliquées ». Entre littérature et philosophie, une zone de « théorie littéraire ».

C’est exactement ce que fait une SOM avec des données. Chaque neurone est comme un étudiant qui trouve sa place sur la grille 2D en se rapprochant de ses semblables. La topologie des relations entre les neurones reflète fidèlement la topologie des similarités entre les données.

Cette intuition explique pourquoi les SOM sont si puissantes pour la visualisation : elles révèlent la structure cachée des données dans un format que l’œil humain sait interpréter naturellement.

Implémentation Python avec MiniSom

Installation

Pour cet article, nous utiliserons MiniSom, une bibliothèque Python légère et bien conçue pour les cartes de Kohonen :

pip install minisom matplotlib seaborn scikit-learn

Exemple complet sur le jeu de données Iris

Voici une implémentation complète qui entraîne une SOM sur le célèbre jeu de données Iris et visualise les résultats :

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from minisom import MiniSom
import seaborn as sns

# 1. Chargement et préparation des données
iris = load_iris()
X = iris.data
y = iris.target
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. Création et entraînement de la SOM
som = MiniSom(x=10, y=10, input_len=4,
              sigma=3.0, learning_rate=0.5,
              distance_metric='euclidean',
              activation_distance='euclidean',
              topology='hexagonal',
              neighborhood_function='gaussian')

som.random_weights_init(X_scaled)
som.train_random(X_scaled, num_iteration=2000)

# 3. Visualisation — carte des clusters
plt.figure(figsize=(12, 4))

# 3a. Mappage des échantillons sur la grille
plt.subplot(1, 2, 1)
colors_map = {0: 'red', 1: 'green', 2: 'blue'}
for i, x in enumerate(X_scaled):
    winner = som.winner(x)
    plt.plot(winner[0] + 0.5, winner[1] + 0.5,
             marker='o', color=colors_map[y[i]],
             markersize=6, alpha=0.6, zorder=2)
plt.title('Carte SOM — Données Iris', fontsize=14, fontweight='bold')
plt.xlabel('Coordonnée x de la grille')
plt.ylabel('Coordonnée y de la grille')
plt.grid(True, alpha=0.3)

# 3b. U-Matrix
def compute_umatrix(som):
    um = np.zeros((som.weights.shape[0], som.weights.shape[1]))
    for i in range(um.shape[0]):
        for j in range(um.shape[1]):
            neighbors = []
            for di in [-1, 0, 1]:
                for dj in [-1, 0, 1]:
                    ni, nj = i + di, j + dj
                    if 0 <= ni < som.weights.shape[0] and 0 <= nj < som.weights.shape[1]:
                        if (di != 0 or dj != 0):
                            dist = np.linalg.norm(
                                som.weights[i, j] - som.weights[ni, nj])
                            neighbors.append(dist)
            um[i, j] = np.mean(neighbors) if neighbors else 0
    return um

plt.subplot(1, 2, 2)
umatrix = compute_umatrix(som)
plt.imshow(umatrix, cmap='viridis', origin='upper', interpolation='nearest')
plt.colorbar(label='Distance moyenne aux voisins')
plt.title('U-Matrix', fontsize=14, fontweight='bold')
plt.xlabel('Coordonnée x')
plt.ylabel('Coordonnée y')

plt.tight_layout()
plt.savefig('som_iris_visualization.png', dpi=150)
plt.show()

# 4. Component Planes
fig, axes = plt.subplots(2, 2, figsize=(10, 10))
feature_names = ['Long. sépale', 'Larg. sépale', 'Long. pétale', 'Larg. pétale']
for k in range(4):
    ax = axes[k // 2, k % 2]
    plane = np.zeros((som.weights.shape[0], som.weights.shape[1]))
    for i in range(som.weights.shape[0]):
        for j in range(som.weights.shape[1]):
            plane[i, j] = som.weights[i, j, k]
    im = ax.imshow(plane, cmap='RdYlBu_r', interpolation='bilinear')
    ax.set_title(f'Component Plane — {feature_names[k]}',
                 fontweight='bold')
    fig.colorbar(im, ax=ax)
plt.tight_layout()
plt.savefig('som_component_planes.png', dpi=150)
plt.show()

La U-Matrix : comprendre les frontières entre clusters

La U-Matrix (Unified Distance Matrix) est l’outil de visualisation le plus puissant des SOM. Pour chaque cellule de la grille, on calcule la distance moyenne entre le poids de cette cellule et ceux de ses voisines. Les zones où ces distances sont élevées correspondent à des frontières entre clusters — ce sont les régions où la carte passe brusquement d’un groupe de données à un autre. À l’inverse, les zones de faible distance indiquent des clusters homogènes.

Component Planes : lire une dimension à la fois

Les component planes permettent de visualiser la contribution de chaque variable originale au positionnement des neurones. En superposant mentalement les component planes, on comprend comment chaque caractéristique influence l’organisation spatiale de la carte. Pour les données Iris, la component plane de la « largeur du pétale » montre une transition très nette qui sépare les trois espèces — c’est la variable la plus discriminante.

Alternative : sklearn-som

Une autre option est le paquet sklearn-som, qui offre une interface de type scikit-learn :

from sklearn_som.som import SOM

som_sk = SOM(m=10, n=10, dim=4, n_iter=2000,
             lr=0.5, random_state=42)
som_sk.fit(X_scaled)
# Les poids sont accessibles via som_sk.weight_vectors_

Cette approche est plus simple mais offre moins de contrôle fin sur la fonction de voisinage et la topologie.

Hyperparamètres clés des SOM

Le choix des hyperparamètres détermine la qualité de la carte finale. Voici les cinq paramètres à maîtriser :

1. Dimension de la grille (x, y)

La forme de la grille conditionne la résolution de la carte.

• Petite grille (5×5) : vue d’ensemble, généralisation élevée.
• Grande grille (20×20) : détails fins, risque de sur-ajustement.
• Règle empirique : 5·√n échantillons pour le nombre total de neurones.

2. Rayon de voisinage initial (σ_0)

Ce paramètre contrôle combien de neurones sont influencés par chaque échantillon au début de l’entraînement.

• σ trop petit : la carte se fragmente, perd sa topologie.
• σ trop grand : la carte s’organise trop globalement, sans détails locaux.
• Valeur recommandée : environ la moitié du plus grand côté de la grille.

3. Taux d’apprentissage initial (α_0)

• Valeur typique : entre 0,3 et 0,7.
• Un α élevé donne une organisation rapide mais grossière.
• Un α faible donne une organisation lente mais précise.

4. Nombre d’itérations (n_iterations)

• Minimum recommandé : 500 × nombre de neurones.
• Trop peu d’itérations : convergence incomplète.
• Trop d’itérations : temps de calcul inutile.

5. Métrique de distance

• Euclidienne (par défaut) : la plus courante, adaptée aux données continues normalisées.
• Manhattan : plus robuste aux valeurs aberrantes (outliers).
• Cosinus : idéale pour les données textuelles ou les vecteurs normalisés.

Avantages et limites des cartes de Kohonen

Avantages

1. Préservation topologique : les relations de voisinage dans l’espace des données sont conservées sur la carte 2D. C’est la propriété distinctive des SOM.
2. Visualisation intuitive : une grille 2D colorée est immédiatement interprétable, même par des non-spécialistes.
3. Apprentissage non supervisé : aucune étiquette n’est nécessaire. Les SOM découvrent seules la structure des données.
4. Robustesse au bruit : grâce à la fonction de voisinage, les données aberrantes ont un impact limité sur la carte globale.
5. Interprétabilité : les component planes révèlent le rôle de chaque variable dans l’organisation des clusters.
6. Flexibilité : adaptables à de nombreux types de données via le choix de la métrique de distance.

Limites

1. Choix des hyperparamètres : la taille de la grille, σ_0 et α_0 sont difficiles à optimiser automatiquement. L’expérience du praticien compte.
2. Sensibilité à l’initialisation : différentes initialisations peuvent produire des cartes distinctes. Il faut souvent exécuter l’algorithme plusieurs fois.
3. Pas de critère objectif d’évaluation : contrairement au K-Means qui fournit un score d’inertie, la qualité d’une SOM s’évalue subjectivement.
4. Coût computationnel : chaque itération nécessite le calcul de distances entre l’échantillon et tous les neurones. Pour des cartes très grandes, cela devient coûteux.
5. Interprétation des bordures : les neurones au bord de la grille ont moins de voisins, ce qui crée un effet de bord (edge effect) qui peut fausser l’analyse.

4 cas d’usage concrets

Cas d’usage 1 : Segmentation de clientèle

Une entreprise de e-commerce dispose de millions de clients décrits par des centaines de variables : fréquence d’achat, panier moyen, catégorie de produits, ancienneté, taux de retour, scores d’engagement… Une SOM permet de projeter cette population multidimensionnelle sur une carte 2D où chaque zone homogène correspond à un segment de clientèle. Un marketeur peut littéralement « lire » la carte : « les clients en haut à gauche sont des acheteurs occasionnels de haute valeur, ceux en bas à droite sont des acheteurs fréquents à petit panier ». Cette segmentation visuelle est bien plus riche qu’un simple clustering par K-Means.

Cas d’usage 2 : Analyse d’images et télédétection

En télédétection satellite, chaque pixel d’une image hyperspectrale contient des centaines de bandes spectrales. Les SOM permettent de regrouper les pixels de même composition matérielle pour produire des cartes de classification thématique : forêts, zones urbaines, plans d’eau, cultures agricoles. La topologie préservée garantit que les zones géographiquement voisines (dans l’espace spectral) restent voisines sur la carte.

Cas d’usage 3 : Analyse exploratoire en biologie

En génomique, les données d’expression de milliers de gènes sont projetées sur une SOM. Les gènes exprimés de manière similaire se regroupent, révélant des modules fonctionnels — des ensembles de gènes qui participent aux mêmes voies métaboliques. Cette approche a été utilisée avec succès dans l’étude des cancers pour identifier des sous-types moléculaires.

Cas d’usage 4 : Détection d’anomalies industrielles

Dans un contexte de maintenance prédictive, les données de capteurs industriels (température, vibration, pression, courant) sont projetées sur une SOM. En fonctionnement normal, les données tombent dans des zones bien identifiées de la carte. Lorsqu’un échantillon atypique se projette sur un neurone peu visité — avec une U-Matrix élevée — c’est le signe d’une anomalie potentielle. Cette méthode non supervisée détecte des dérives sans avoir besoin d’exemples de pannes étiquetées.

Comparaison avec d’autres méthodes

Contrairement au K-Means qui produit des clusters disjoints, la SOM offre une continuité spatiale entre les régions. Contrairement à l’ACP qui est linéaire, la SOM capture des relations non linéaires. Et contrairement à t-SNE qui sacrifie la structure globale, la SOM offre un compromis entre fidélité locale et globale.

Conclusion

Les Self-Organizing Maps de Kohonen demeurent, quarante ans après leur invention, l’un des algorithmes les plus fascinants de l’apprentissage non supervisé. Leur beauté réside dans leur simplicité conceptuelle — un réseau de neurones qui s’auto-organise sur une grille — et dans la richesse de l’information qu’elles révèlent.

En pratique, les SOM excellent dans les situations où l’interprétabilité visuelle est aussi importante que la performance algorithmique. Quand un décideur a besoin de comprendre la structure de ses données, quand un explorateur veut naviguer dans un espace complexe, quand un scientifique cherche à découvrir des patterns cachés — la carte de Kohonen est un compagnon de choix.

La clé du succès avec les SOM ? Expérimenter. Testez plusieurs tailles de grille, variez les hyperparamètres, comparez les visualisations. La première carte vous donnera une intuition, la dixième vous donnera des réponses.

Voir aussi

• Calculer le Totient d’un Carré en Cube avec Python : Guide Pratique et Astuces
• Créer des Ellipses Croisées en Python : Guide Complet pour la Visualisation et la Manipulation