RBF Network : Guide complet — Principes, Exemples et Implémentation Python
Résumé
Le RBF Network (Radial Basis Function Network, ou réseau de neurones à fonction de base radiale) est une architecture de réseau de neurones artificiels qui se distingue fondamentalement du perceptron multicouche classique (MLP). Au lieu d’utiliser des fonctions d’activation sigmoïdes ou ReLU dans sa couche cachée, le RBF Network emploie des fonctions radiales gaussiennes centrées autour de points de référence dans l’espace d’entrée. Cette approche lui confère des propriétés d’approximation universelle, une convergence rapide et une interprétabilité géométrique que peu d’autres modèles peuvent égaler. Dans ce guide complet, nous explorerons les principes mathématiques, l’intuition géométrique, l’implémentation from scratch en Python, ainsi que les cas d’usage pratiques du RBF Network.
Principe mathématique
La couche RBF : fonctions gaussiennes
Le cœur du RBF Network réside dans sa couche cachée, composée de neurones à fonction de base radiale. Chaque neurone i calcule une réponse en fonction de la distance entre le vecteur d’entrée x et un centre cₗ qui lui est propre :
φₖ(x) = exp( -||x – cₖ||² / (2σₖ²) )
où :
- x ∈ ℝⁿ est le vecteur d’entrée de dimension n
- cₖ ∈ ℝⁿ est le centre du i-ième neurone RBF — un point de référence dans l’espace d’entrée
- σₖ > 0 est le paramètre de largeur (ou spread) du i-ième neurone, qui contrôle la portée de la zone d’influence
- ||x – cₖ|| est la distance euclidienne entre l’entrée et le centre
- φₖ(x) est la sortie du neurone RBF, toujours comprise entre 0 et 1
Cette fonction gaussienne atteint sa valeur maximale (1) lorsque l’entrée coïncide exactement avec le centre cₖ, puis décroît de façon exponentielle à mesure que l’entrée s’éloigne du centre. Le paramètre σₖ détermine la vitesse de cette décroissance : un σ petit crée une gaussienne étroite et sélective, tandis qu’un σ large produit une réponse plus douce et généralisée.
La couche de sortie
La sortie finale du réseau est une combinaison linéaire des activations de la couche RBF :
y = Σ wₖ · φₖ(x) + b
où :
- wₖ est le poids associé au i-ième neurone RBF
- b est le terme de biais
- La somme porte sur tous les neurones de la couche cachée
Contrairement au MLP qui empile des couches non linéaires, le RBF Network n’applique qu’une seule transformation non linéaire (les gaussiennes), suivie d’un unique calcul linéaire. Cette simplicité structurelle est à la fois sa force et sa faiblesse.
Apprentissage en deux phases
L’entraînement du RBF Network se déroule typiquement en deux phases distinctes, ce qui le rend beaucoup plus rapide à entraîner qu’un réseau à rétropropagation classique :
Phase 1 — Détermination des centres (non supervisé) : Les centres cₖ des neurones RBF sont positionnés dans l’espace d’entrée à l’aide de l’algorithme K-Means. L’idée est de placer chaque centre au cœur d’un groupement naturel de données. Le paramètre σₖ est ensuite calculé à partir des distances entre centres (par exemple, la distance moyenne au centre le plus proche ou la distance maximale inter-centres divisée par √(2K)).
Phase 2 — Calcul des poids de sortie (supervisé) : Une fois les centres et les largeurs fixés, les activations φₖ(x) deviennent des fonctionnalités connues pour chaque exemple d’entraînement. Les poids wₖ et le biais b sont alors déterminés par régression linéaire des moindres carrés (directe ou régularisée par ridge regression), ou plus rarement par descente de gradient.
Cette séparation est élégante : la première phase capture la structure géométrique des données sans connaître les étiquettes, et la seconde résout un simple problème d’algèbre linéaire.
Intuition : des zones d’influence
Pour vraiment comprendre le RBF Network, il faut dépasser les formules et développer une intuition géométrique.
Imaginez un espace à deux dimensions rempli de données. Plaćons quelques points de référence — nos centres RBF — dispersés dans cet espace. Chaque centre est entouré d’une zone d’influence en forme de cloche (la gaussienne). Quand un point d’entrée arrive, il « active » chaque zone d’influence proportionnellement à sa proximité : plus il est proche d’un centre, plus le neurone correspondant s’active.
La sortie finale est simplement une moyenne pondérée de toutes ces activations. Chaque neurone contribue à la prédiction selon deux critères : à quel point l’entrée est proche de son centre (via φₖ) et quelle importance le modèle a attribuée à ce centre (via wₖ).
Au lieu de détecter des patterns linéaires comme un MLP, chaque neurone RBF détecte si l’entrée est proche de son centre — c’est comme avoir des zones d’influence autour de points de référence, et la sortie est une moyenne pondérée de ces zones.
La différence fondamentale avec un MLP (perceptron multicouche) est subtile mais puissante :
- Un MLP utilise des hyperplans pour découper l’espace : chaque neurone détecte si l’entrée se trouve d’un côté ou de l’autre d’une frontière linéaire. En empilant les couches, on construit des frontières complexes.
- Un RBF Network utilise des sphères (ou ellipsoïdes) : chaque neurone détecte si l’entrée est « dans le voisinage » de son centre. La combinaison de ces zones sphériques permet d’approximer n’importe quelle fonction continue.
On peut voir le RBF Network comme un système d’interpolation locale : chaque région de l’espace a son propre « expert » local (le neurone dont le centre est le plus proche), et la prédiction résulte d’un mélange fluide entre experts voisins.
Implémentation Python
Version from scratch avec KMeans
Voici une implémentation complète du RBF Network à partir de zéro, en utilisant uniquement NumPy et scikit-learn pour le KMeans (les centres) :
import numpy as np
from sklearn.cluster import KMeans
from numpy.linalg import pinv
class RBFNetwork:
"""Réseau de neurones à fonction de base radiale (RBF Network)
implémenté from scratch avec NumPy."""
def __init__(self, n_centers=10, sigma=None):
self.n_centers = n_centers
self.sigma = sigma # Si None, calculé automatiquement
self.centers = None # Centres c_i appris par K-Means
self.weights = None # Poids w_i de la couche de sortie
self.bias = None # Biais b
def _gaussian(self, X, centers, sigma):
"""Calcule la matrice des activations gaussiennes.
Résultat : shape (n_samples, n_centers)"""
distances = np.zeros((X.shape[0], len(centers)))
for i, center in enumerate(centers):
distances[:, i] = np.linalg.norm(X - center, axis=1)
return np.exp(-(distances ** 2) / (2 * sigma ** 2))
def _compute_sigma(self):
"""Calcule sigma automatiquement comme la distance maximale
entre centres divisée par sqrt(2 * n_centers)."""
max_dist = 0
for i in range(len(self.centers)):
for j in range(i + 1, len(self.centers)):
d = np.linalg.norm(self.centers[i] - self.centers[j])
if d > max_dist:
max_dist = d
return max_dist / np.sqrt(2 * self.n_centers)
def fit(self, X, y):
"""Entraînement en deux phases."""
# Phase 1 : centres par K-Means
kmeans = KMeans(n_clusters=self.n_centers, random_state=42, n_init=10)
kmeans.fit(X)
self.centers = kmeans.cluster_centers_
# Calcul automatique de sigma si non spécifié
if self.sigma is None:
self.sigma = self._compute_sigma()
# Calcul de la matrice d'activation RBF (Phi)
Phi = self._gaussian(X, self.centers, self.sigma)
# Phase 2 : régression linéaire (moindres carrés avec pseudo-inverse)
# Ajout d'une colonne de 1 pour le biais
Phi_bias = np.column_stack([Phi, np.ones(Phi.shape[0])])
# Résolution par pseudo-inverse de Moore-Penrose
params = pinv(Phi_bias) @ y
self.weights = params[:-1]
self.bias = params[-1]
return self
def predict(self, X):
"""Prédiction sur de nouvelles données."""
Phi = self._gaussian(X, self.centers, self.sigma)
return Phi @ self.weights + self.bias
Exemple d’utilisation : approximation de fonction non linéaire
import matplotlib.pyplot as plt
# Génération de données : fonction sinusoïdale bruitée
np.random.seed(42)
X_train = np.linspace(-3, 3, 100).reshape(-1, 1)
y_train = np.sin(X_train.flatten()) + 0.1 * np.random.randn(100)
# Entraînement du RBF Network
rbf = RBFNetwork(n_centers=15, sigma=0.4)
rbf.fit(X_train, y_train)
# Prédiction sur une grille fine
X_test = np.linspace(-4, 4, 300).reshape(-1, 1)
y_pred = rbf.predict(X_test)
# Visualisation
plt.figure(figsize=(10, 6))
plt.scatter(X_train, y_train, alpha=0.5, label="Données d'entraînement", s=15)
plt.plot(X_test, y_pred, 'r-', linewidth=2, label="Prédiction RBF Network")
plt.plot(X_test, np.sin(X_test.flatten()), 'g--', label="sin(x) (vérité)", linewidth=1.5)
plt.scatter(rbf.centers.flatten(), rbf.predict(rbf.centers),
marker='x', c='purple', s=80, label="Centres RBF")
plt.legend()
plt.title("RBF Network : Approximation de sin(x)")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
Avec scipy.interpolate (approche alternative)
Pour certains cas d’usage, la bibliothèque SciPy propose une implémentation optimisée de l’interpolation RBF :
from scipy.interpolate import RBFInterpolator
# Mêmes données
rbf_scipy = RBFInterpolator(X_train, y_train,
kernel='gaussian',
smoothing=0.01)
y_pred_scipy = rbf_scipy(X_test)
La fonction RBFInterpolator de SciPy utilise des algorithmes numériques optimisés et peut traiter des problèmes de plus grande taille grâce à des solveurs creux (sparse).
Cas d’approximation 2D
Le RBF Network fonctionne naturellement en dimensions supérieures :
# Données 2D : approximation d'une surface z = f(x, y)
X_2d = np.random.uniform(-2, 2, (200, 2))
y_2d = np.exp(-(X_2d[:, 0]**2 + X_2d[:, 1]**2)) + 0.05 * np.random.randn(200)
rbf_2d = RBFNetwork(n_centers=20)
rbf_2d.fit(X_2d, y_2d)
print(f"Erreur quadratique moyenne : {np.mean((rbf_2d.predict(X_2d) - y_2d)**2):.6f}")
Hyperparamètres clés
Le RBF Network possède trois hyperparamètres principaux qui influencent directement ses performances :
n_centers (nombre de neurones RBF)
Le nombre de centres contrôle la capacité du modèle :
- Trop peu de centres : le modèle est sous-ajusté, il ne capture pas les variations fines de la fonction cible.
- Trop de centres : risque de surapprentissage, le modèle mémorise le bruit des données d’entraînement. De plus, le coût computationnel de la régression linéaire croît en O(n_centers² · n_samples).
En pratique, on choisit n_centers entre 5% et 30% du nombre d’exemples d’entraînement, selon la complexité de la fonction à approximer.
sigma / width (largeur des gaussiennes)
Le paramètre σ contrôle la portée de chaque neurone :
- σ petit : chaque neurone a une zone d’influence étroite. Le modèle devient très local et peut surapprendre.
- σ grand : les zones d’influence se chevauchent largement. Le modèle se comporte presque comme une régression linéaire.
La règle empirique courante consiste à calculer σ à partir des distances inter-centres :
σ = d_max / √(2 · K)
où d_max est la distance maximale entre deux centres et K le nombre de centres. On peut aussi utiliser la distance moyenne au centre le plus proche (k-nearest neighbor distance).
Régularisation
Lorsqu’on résout le système linéaire en phase 2, on peut ajouter une régularisation de type ridge (Tikhonov) pour éviter le surapprentissage :
w = (ΦᵀΦ + λI)⁻¹ Φᵀy
Au lieu d’utiliser la pseudo-inverse, on résout un système régularisé où λ ≥ 0 contrôle la pénalisation des grands poids. Un λ élevé lisse la solution ; un λ nul revient aux moindres carrés classiques.
Avantages et Limites
Avantages
- Entraînement rapide : La séparation en deux phases (clustering non supervisé + régression linéaire) évite les boucles d’optimisation coûteuses de la rétropropagation. Pas d’epochs, pas de learning rate, pas de vanishing gradient.
- Approximation universelle : Comme le MLP, le RBF Network peut approximer n’importe quelle fonction continue sur un domaine compact avec une précision arbitraire (théorème de Park & Sandberg, 1991).
- Interprétabilité géométrique : Chaque centre a une signification spatiale claire. On peut visualiser où le modèle place ses « experts » dans l’espace d’entrée.
- Pas de minimum local : La phase 2 (régression linéaire) est un problème convexe — on trouve toujours la solution globale optimale pour les poids de sortie.
- Excellente interpolation : Idéal pour les problèmes où les données d’entraînement couvrent bien l’espace et où on cherche des prédictions précises entre les points connus.
Limites
- Malédiction de la dimensionalité : En haute dimension (d > 50), les distances euclidiennes perdent leur pouvoir discriminatif. Tous les points deviennent « équidistants » et les gaussiennes s’aplatissent.
- Extrapolation faible : Le RBF Network est un interpolateur. Pour des points très éloignés de tous les centres, toutes les activations φₖ tendent vers 0 et la prédiction converge vers le biais b — peu utile.
- Choix des hyperparamètres sensible : Le nombre de centres et la largeur σ ont un impact dramatique sur les performances, et leur optimisation nécessite une validation croisée coûteuse.
- Mémoire importante : Le modèle doit stocker tous les centres et, pour chaque prédiction, calculer les distances à tous les centres. La complexité en prédiction est O(n_centers · n_features).
- Moins puissant que le deep learning : Pour des tâches comme la vision par ordinateur ou le traitement du langage naturel, les réseaux profonds avec rétropropagation surpassent largement les RBF Networks.
4 cas d’usage pratiques
1. Approximation de fonctions et modélisation de systèmes physiques
Le RBF Network excelle dans l’approximation de fonctions non linéaires complexes. En ingénierie, on l’utilise pour créer des modèles substituts (surrogate models) de simulations numériques coûteuses : au lieu de re-exécuter une simulation CFD (computational fluid dynamics) qui prend des heures, on entraîne un RBF Network sur un échantillon de résultats et on obtient des prédictions quasi-instantanées.
2. Classification médicale et diagnostic assisté
En raison de sa nature locale, le RBF Network se prête bien à la classification de données médicales : détection de tumeurs, diagnostic de maladies cardiovasculaires, analyse de signaux EEG. Les centres appris par K-Means correspondent souvent à des prototypes cliniquement interprétables. Sa rapidité d’entraînement est un atout quand les données sont de taille modérée.
3. Contrôle de robots et systèmes temps réel
Les RBF Networks sont utilisés dans le contrôle adaptatif de robots et les systèmes de commande en temps réel. Leur capacité à approximer des fonctions non linéaires inconnues permet de construire des contrôleurs qui compensent les non-linéarités du système (frottements, flexibilité mécanique) sans modèle analytique précis. La rapidité de prédiction les rend compatibles avec les contraintes temporelles strictes.
4. Prédiction de séries temporelles
En finance, météorologie ou gestion de l’énergie, le RBF Network peut modéliser des séries temporelles non linéaires. On reformule le problème de prédiction comme une approximation de fonction : les entrées sont les k dernières valeurs observées et la sortie est la valeur future. Les neurones RBF capturent les régimes locaux de la série (tendance haussière, consolidation, volatilité élevée) à travers leurs centres positionnés dans l’espace des retards temporels.
Voir aussi
- Démystifiez le Module ‘abc’ en Python : Guide Complet avec Exemples Pratiques
- Maîtriser le Jeu ‘Lights Out’ avec Python : Tutoriel Complet et Code Source
