Signature Transform : Guide Complet — Transformée de Signature pour Séries Temporelles

Résumé

Le Signature Transform est une méthode mathématique puissante issue de la théorie des chemins rugueux (rough path theory) de Terry Lyons. Contrairement aux approches classiques qui traitent les séries temporelles comme des suites de nombres discrets, le Signature Transform considère une série temporelle comme un chemin continu dans un espace multidimensionnel. La signature de ce chemin — une collection d’intégrales itérées de Chen — encode l’intégralité de l’information géométrique et dynamique du chemin, à équivalence de reparamétrage près.

Cette approche offre une représentation extrêmement riche des données séquentielles, particulièrement adaptée aux séries temporelles irrégulièrement échantillonnées, aux données manquantes, et aux problèmes où l’ordre et les interactions entre variables sont primordiaux. Depuis son introduction dans le domaine de l’apprentissage automatique vers 2015-2016 par les travaux de Terry Lyons, Harald Oberhauser et leurs collaborateurs, le Signature Transform a connu une adoption croissante, notamment en finance quantitative, en reconnaissance de gestes et en analyse médicale de signaux physiologiques.

Dans ce guide complet, nous explorons la théorie mathématique sous-jacente, l’intuition derrière la méthode, son implémentation pratique en Python, et ses applications concrètes dans divers domaines.

Principe Mathématique

La signature d’un chemin : définition fondamentale

Formellement, soit un chemin continu $X : [0, T] \to \mathbb{R}^d$, où $d$ représente le nombre de dimensions (ou de variables observées). La signature de ce chemin, notée $S(X)$, est définie comme la collection de tous ses itérés d’intégrales de Chen :

$$S(X) = \left(1,\; S^1(X),\; S^2(X),\; S^3(X),\; \ldots\right)$$

où chaque terme d’ordre $k$ est défini par :

$$S^k(X) = \int_{0 < t_1 < t_2 < \cdots < t_k < T} dX_{t_1} \otimes dX_{t_2} \otimes \cdots \otimes dX_{t_k}$$

Chaque terme d’ordre $k$ capture les interactions d’ordre $k$ entre les dimensions du chemin. Plus précisément :

• Ordre 0 : le scalaire 1 (terme constant).
• Ordre 1 : $\int_0^T dX_t^i = X_T^i – X_0^i$, c’est-à-dire le changement net de chaque dimension. Pour une série temporelle, cela correspond au déplacement total de chaque variable entre le début et la fin.
• Ordre 2 : $\int_0^T \int_0^{t_2} dX_{t_1}^i \, dX_{t_2}^j$, qui capture les interactions quadratiques entre paires de dimensions, y compris l’aire signée balayée entre les trajectoires. Ce terme encode non seulement la corrélation entre variables, mais aussi leur ordre temporel : quelle variable évolue avant l’autre ?
• Ordre 3 et supérieur : les interactions d’ordre supérieur capturent des dépendances temporelles toujours plus subtiles, intégrant des effets triples, quadruples, etc., entre les dimensions du chemin. Chaque terme d’ordre $k$ est un tenseur de rang $k$ de dimension $d^k$.

Le théorème de Hambly-Lyons

Un résultat fondamental, démontré par Hambly et Lyons en 2010, établit que la signature caractérise un chemin à équivalence de reparamétrage près. Autrement dit, deux chemins ont la même signature si et seulement si l’un est un reparamétrage de l’autre (c’est-à-dire qu’ils parcourent la même trajectoire géométrique, potentiellement à des vitesses différentes). Cette propriété est remarquable : elle signifie que la signature capture l’essence géométrique du chemin, indépendamment de la vitesse à laquelle il est parcouru.

Ce théorème justifie entièrement l’usage de la signature pour l’analyse de séries temporelles : peu importe que les observations soient espacées de manière régulière ou irrégulière, la signature encode la même information géométrique fondamentale.

Troncature et dimensionnalité

En pratique, on ne peut pas calculer une signature d’ordre infini. On tronque la signature à une profondeur maximale $m$, ce qui donne une signature tronquée :

$$S^{(m)}(X) = \left(1,\; S^1(X),\; S^2(X),\; \ldots,\; S^m(X)\right)$$

L’espace des signatures tronquées est de dimension finie :

$$\text{dim} = d + d^2 + d^3 + \cdots + d^m = \sum_{k=1}^{m} d^k$$

Par exemple, pour $d = 3$ dimensions et une profondeur $m = 3$ :
– Ordre 1 : $3$ coefficients
– Ordre 2 : $3^2 = 9$ coefficients
– Ordre 3 : $3^3 = 27$ coefficients
– Total : $3 + 9 + 27 = 39$ coefficients (plus le terme constant 1)

L’augmentation exponentielle de la dimensionnalité avec la profondeur est un défi majeur : choisir $m$ trop grand conduit rapidement à la malédiction de la dimensionnalité. Pour cette raison, les profondeurs typiques se situent entre 2 et 5 dans les applications pratiques.

Invariance au reparamétrage temporel

La propriété la plus remarquable du Signature Transform est son invariance au reparamétrage temporel. Si deux chemins parcourent les mêmes points dans le même ordre, mais à des vitesses différentes, leurs signatures seront identiques. Cette propriété rend la signature idéalement adaptée aux séries temporelles irrégulièrement échantillonnées, un cas de figure extrêmement courant en pratique :

• Données financières (transactions à intervalles irréguliers)
• Capteurs médicaux (mesures prises à des moments non uniformes)
• Données de suivi GPS (points enregistrés à des fréquences variables selon le mouvement)
• Logs applicatifs (événements survenant de manière asynchrone)

Contrairement aux méthodes classiques comme les RNN ou les LSTM qui supposent un espacement temporel uniforme, le Signature Transform fonctionne naturellement avec des données irrégulières, sans imputation ni interpolation préalable.

Intuition : La Signature Comme Résumé Statistique Complet

Pour comprendre l’intuition derrière le Signature Transform, considérons une analogie narrative.

Si une série temporelle est une histoire, la signature en est le résumé statistique complet. Imaginez que vous lisiez un roman et que vous deviez en extraire l’essentiel :

• Les statistiques d’ordre 1 (termes du premier ordre de la signature) vous donnent les grandes lignes : où commence l’histoire, où elle se termine, de combien chaque personnage a évolué. C’est l’équivalent d’un résumé Wikipedia — les faits bruts.
• Les statistiques d’ordre 2 révèlent les interactions entre les personnages et les événements. Est-ce que le héros agit avant ou après le méchant ? Les variables évoluent-elles dans le même sens ou en sens opposé ? Quelle est l‘“aire” balayée par leur évolution conjointe ? C’est l’équivalent d’une analyse des relations causales et temporelles.
• Les statistiques d’ordre 3 et supérieur capturent des dépendances encore plus sophistiquées : des schémas complexes impliquant trois variables ou plus, des boucles de rétroaction, des comportements émergents qui ne sont pas visibles dans les interactions par paires.

C’est comme la différence entre lire un résumé de livre et lire le livre entier. Le résumé d’ordre 1 vous dit que “le héros part en quête et revient victorieux”. L’ordre 2 vous révèle que “pendant son voyage, il a rencontré son alliée avant de découvrir le trésor, et cette séquence d’événements était cruciale”. L’ordre 3 ajoute que “c’est précisément parce qu’il a rencontré son alliée en premier, puis découvert le trésor, et ensuite affronté le dragon, que la victoire a été possible — un ordre différent aurait tout changé”.

Cette richesse informationnelle explique pourquoi le Signature Transform est si puissant : il encode non seulement les valeurs statistiques classiques (moyenne, variance, dérivées), mais aussi comment les variables interagissent dans le temps, dans quel ordre, avec quelle intensité relative.

Comparaison avec les approches classiques

Contrairement aux RNN et LSTM qui apprennent des représentations de manière implicite à travers des poids ajustés par rétropropagation, le Signature Transform fournit une transformation déterministe et non paramétrique du chemin original. Il n’y a rien à “apprendre” pour calculer la signature elle-même — c’est une transformation mathématique fixe et explicite.

Cette nature déterministe confère plusieurs avantages :
– Reproductibilité garantie : la même entrée produit toujours la même signature.
– Interprétabilité : chaque coefficient de la signature a une signification mathématique précise.
– Pas besoin de données d’entraînement pour la transformation elle-même : la signature se calcule directement à partir du chemin, sans phase d’apprentissage.

En pratique, on utilise souvent la signature comme couche de prétraitement (feature extraction), suivie d’un modèle supervisé léger (régression linéaire, SVM, réseau linéaire) pour la tâche finale. Cette approche combine la richesse de la signature avec la puissance prédictive des modèles supervisés.

Implémentation Python

Prérequis

La bibliothèque de référence pour le calcul de signatures en Python est iisignature, une bibliothèque C++ extrêmement optimisée. On l’installe simplement :

pip install iisignature numpy scikit-learn torch

Exemple 1 : Calcul de la signature d’un chemin simple

Commençons par un exemple fondamental — le calcul de la signature d’un chemin en deux dimensions :

import numpy as np
import iisignature

# Définir un chemin en 2D
# Chaque ligne représente un point (x, y) le long du chemin
chemin = np.array([
    [0.0, 0.0],
    [1.0, 0.5],
    [1.5, 1.5],
    [2.0, 1.0],
    [2.5, 2.0]
])

d = chemin.shape[1]  # nombre de dimensions = 2
m = 3  # profondeur de troncature = 3

# Calculer la signature
signature = iisignature.sig(chemin, m)

print(f"Dimensions du chemin : {d}")
print(f"Profondeur de troncature : {m}")
print(f"Signature (dim = {len(signature)}): {signature}")

# Vérifier la dimension théorique
# dim = d + d² + d³ = 2 + 4 + 8 = 14
dim_theorique = sum(d**k for k in range(1, m+1))
print(f"Dimension théorique : {dim_theorique}")
assert len(signature) == dim_theorique, "Dimension incorrecte !"

Ce code produit une signature de dimension 14 pour un chemin en 2D tronqué à l’ordre 3. La signature commence toujours par le terme constant 1, suivi des $d$ termes d’ordre 1, puis des $d^2$ termes d’ordre 2, et ainsi de suite.

Exemple 2 : Préparation des séries temporelles pour la signature

Une étape cruciale est la préparation des données. Le Signature Transform opère sur des chemins, qui sont des séquences de points dans $\mathbb{R}^d$. Pour une série temporelle univariée traditionnelle (un seul nombre par pas de temps), il est souvent bénéfique d’enrichir le chemin avant calcul :

import numpy as np
import iisignature

def preparer_chemin(series, include_temps=True, include_cume=True):
    """
    Préparer un chemin à partir d'une série temporelle univariée.

    Arguments :
        series : np.array de forme (T, ) — série temporelle
        include_temps : bool — ajouter le temps comme dimension
        include_cume : bool — ajouter l'intégrale cumulée (lead-lag)

    Retourne :
        chemin : np.array de forme (T, d) — chemin préparé
    """
    T = len(series)

    # Commencer avec la série elle-même (éventuellement reshaped)
    dims = [series.reshape(-1, 1)]

    if include_temps:
        # Ajouter le temps normalisé comme dimension
        t = np.linspace(0, 1, T).reshape(-1, 1)
        dims.append(t)

    if include_cume:
        # Ajouter l'intégrale cumulée (variante du lead-lag)
        cume = np.cumsum(series).reshape(-1, 1)
        # Normaliser pour la stabilité numérique
        cume = cume / (np.abs(cume).max() + 1e-8)
        dims.append(cume)

    chemin = np.concatenate(dims, axis=1)
    return chemin

# Exemple d'utilisation
serie = np.sin(np.linspace(0, 4*np.pi, 100)) + 0.1 * np.random.randn(100)
chemin = preparer_chemin(serie, include_temps=True, include_cume=True)
print(f"Forme du chemin : {chemin.shape}")  # (100, 3) — valeur, temps, intégrale cumulée

L’ajout du temps comme dimension est particulièrement important : il permet à la signature de distinguer des chemins qui parcourent les mêmes points spatiaux mais à des vitesses différentes (bien que la signature soit invariante au reparamétrage, l’ajout du temps comme coordonnée crée un chemin dans un espace augmenté qui encode implicitement la dynamique temporelle).

L’ajout de l’intégrale cumulée (technique du lead-lag) est une astuce classique qui double l’information disponible : au lieu d’avoir simplement $(X_t, Y_t)$ à chaque instant, on a $(X_t, Y_t, \int_0^t X_s ds, \int_0^t Y_s ds)$. Cette augmentation du chemin enrichit considérablement la signature calculée.

Exemple 3 : Classification de séries temporelles avec signature

Voici un exemple complet de classification de séries temporelles utilisant le Signature Transform couplé à un réseau linéaire (PyTorch) :

import numpy as np
import iisignature
import torch
import torch.nn as nn
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report

# ------------------------------------------------
# 1. Génération de données synthétiques
# ------------------------------------------------

def generer_donnees(n_echantillons, longueur, n_classes):
    """Générer des données de séries temporelles synthétiques."""
    X, y = [], []

    if n_classes == 2:
        for i in range(n_echantillons):
            if i < n_echantillons // 2:
                # Classe 0 : sinusoïde avec bruit faible
                serie = np.sin(np.linspace(0, 3*np.pi, longueur)) + 0.1 * np.random.randn(longueur)
            else:
                # Classe 1 : cosinusoïde avec décalage
                serie = np.cos(np.linspace(0, 3*np.pi, longueur)) + 0.1 * np.random.randn(longueur)
            X.append(serie)
            y.append(i < n_echantillons // 2)

    return np.array(X), np.array(y, dtype=int)

# Créer les données
n_echantillons = 500
longueur = 50
X_donnees, y_donnees = generer_donnees(n_echantillons, longueur, 2)

# ------------------------------------------------
# 2. Préparation des chemins et calcul des signatures
# ------------------------------------------------

def calculer_signatures(X, profondeur=3):
    """Calculer les signatures pour toutes les séries."""
    signatures = []
    for serie in X:
        chemin = preparer_chemin(serie, include_temps=True, include_cume=True)
        sig = iisignature.sig(chemin, profondeur)
        signatures.append(sig)
    return np.array(signatures)

profondeur = 3
X_signatures = calculer_signatures(X_donnees, profondeur=profondeur)

# Normalisation des signatures (comme pour toute feature)
scaler = StandardScaler()
X_signatures = scaler.fit_transform(X_signatures)

print(f"Forme des signatures : {X_signatures.shape}")
print(f"Nombre de features après signature : {X_signatures.shape[1]}")

# ------------------------------------------------
# 3. Division train/test
# ------------------------------------------------

X_train, X_test, y_train, y_test = train_test_split(
    X_signatures, y_donnees, test_size=0.2, random_state=42, stratify=y_donnees
)

# ------------------------------------------------
# 4. Modèle : réseau linéaire simple sur les signatures
# ------------------------------------------------

class SignatureClassifier(nn.Module):
    """Classifieur linéaire sur les features de signature."""

    def __init__(self, n_features, n_classes):
        super().__init__()
        self.reseau = nn.Sequential(
            nn.Linear(n_features, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(32, n_classes)
        )

    def forward(self, x):
        return self.reseau(x)

# Initialisation
n_features = X_signatures.shape[1]
n_classes = 2
modele = SignatureClassifier(n_features, n_classes)

# Conversion en tenseurs
X_train_t = torch.tensor(X_train, dtype=torch.float32)
y_train_t = torch.tensor(y_train, dtype=torch.long)
X_test_t = torch.tensor(X_test, dtype=torch.float32)
y_test_t = torch.tensor(y_test, dtype=torch.long)

# ------------------------------------------------
# 5. Entraînement
# ------------------------------------------------

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(modele.parameters(), lr=1e-3)

n_epochs = 100
batch_size = 32

for epoch in range(n_epochs):
    modele.train()
    # Mini-batch
    permutation = torch.randperm(X_train_t.size(0))
    pertes_epoch = []

    for i in range(0, X_train_t.size(0), batch_size):
        indices = permutation[i:i+batch_size]
        batch_X = X_train_t[indices]
        batch_y = y_train_t[indices]

        optimizer.zero_grad()
        predictions = modele(batch_X)
        perte = criterion(predictions, batch_y)
        perte.backward()
        optimizer.step()
        pertes_epoch.append(perte.item())

    if (epoch + 1) % 20 == 0:
        modele.eval()
        with torch.no_grad():
            test_preds = modele(X_test_t).argmax(dim=1).numpy()
            acc = accuracy_score(y_test, test_preds)
            print(f"Epoch {epoch+1}/{n_epochs} — "
                  f"Perte moyenne : {np.mean(pertes_epoch):.4f} — "
                  f"Précision test : {acc:.4f}")

# Évaluation finale
modele.eval()
with torch.no_grad():
    test_preds = modele(X_test_t).argmax(dim=1).numpy()
    print(f"\nPrécision finale : {accuracy_score(y_test, test_preds):.4f}")
    print(classification_report(y_test, test_preds))

Exemple 4 : Application aux données financières irrégulières

Le Signature Transform excelle particulièrement dans le domaine financier, où les données sont naturellement irrégulièrement espacées :

import numpy as np
import iisignature
from sklearn.ensemble import RandomForestClassifier

def preparer_chemin_financier(prix, volumes=None, intervalles=None):
    """
    Préparer un chemin pour des données financières irrégulières.

    Arguments :
        prix : np.array — prix à chaque transaction
        volumes : np.array ou None — volumes de transaction
        intervalles : np.array ou None — temps entre transactions

    Retourne :
        chemin : np.array — chemin multi-dimensionnel prêt pour la signature
    """
    T = len(prix)
    dims = []

    # Retour logarithmique (plus stable que les prix bruts)
    ret_log = np.diff(np.log(prix + 1e-8))
    ret_log = np.concatenate([[0], ret_log])
    dims.append(ret_log.reshape(-1, 1))

    # Prix normalisé
    prix_norm = (prix - prix[0]) / (prix[0] + 1e-8)
    dims.append(prix_norm.reshape(-1, 1))

    if volumes is not None:
        vol_norm = volumes / (volumes.max() + 1e-8)
        dims.append(vol_norm.reshape(-1, 1))

    if intervalles is not None:
        # Délais entre transactions (crucial pour l'irrégularité)
        dt_norm = intervalles / (intervalles.max() + 1e-8)
        dims.append(dt_norm.reshape(-1, 1))

    # Temps absolu
    t = np.linspace(0, 1, T).reshape(-1, 1)
    dims.append(t)

    return np.concatenate(dims, axis=1)

# Simulation de données de transactions irrégulières
signaux = np.random.choice([-1, 1], size=300)

X_fin, y_fin = [], []
for i in range(300):
    n = np.random.randint(50, 200)
    # Prix simulés avec tendance
    rets = 0.001 * np.random.randn(n)
    if signaux[i] == 1:
        rets += 0.0005  # Tendance haussière subtile
    prix = 100 * np.exp(np.cumsum(rets))

    # Intervalles irréguliers (modélise les pauses dans le trading)
    intervalles = np.abs(np.random.exponential(scale=2.0, size=n))
    volumes = np.random.lognormal(mean=3, sigma=1, size=n)

    chemin = preparer_chemin_financier(prix, volumes, intervalles)
    sig = iisignature.sig(chemin, m=3)
    X_fin.append(sig)
    y_fin.append((signaux[i] + 1) // 2)

X_fin = np.array(X_fin)
y_fin = np.array(y_fin)

# Classification avec Random Forest (modèle non linéaire sur les signatures)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X_fin, y_fin, test_size=0.2, random_state=42
)

rf = RandomForestClassifier(n_estimators=100, max_depth=8, random_state=42)
rf.fit(X_train, y_train)
acc = rf.score(X_test, y_test)
print(f"Précision Random Forest sur signatures financières : {acc:.4f}")

Ce dernier exemple illustre la puissance du Signature Transform dans un contexte réaliste : des transactions avec des intervalles irréguliers, des volumes variables, et un signal faible à détecter. La signature capture les motifs géométriques subtils des prix que des approches basées sur des fenêtres temporelles fixes manqueraient.

Hyperparamètres

Profondeur de signature (signature_depth / m)

C’est l’hyperparamètre le plus critique du Signature Transform. La profondeur détermine l’ordre maximal des intégrales itérées incluses dans la représentation.

Recommandations pratiques :

• Commencez toujours par m = 3 — c’est le point de référence standard dans la littérature et fonctionne bien dans la majorité des cas.
• Si vos données sont très bruitées, réduisez à m = 2 pour éviter le sur-apprentissage.
• Si vous avez beaucoup de données et un problème complexe, essayez m = 4, mais surveillez rigoureusement la performance sur l’ensemble de validation.
• Évitez m > 5 sauf dans des cas exceptionnels : la dimension explose et le risque de sur-apprentissage devient très élevé.

Nombre de features après signature (num_features_after_signature)

Ce nombre est déterministe et dépend uniquement de $d$ (nombre de dimensions du chemin) et $m$ (profondeur) :

$$\text{num_features} = \sum_{k=1}^{m} d^k$$

Il est crucial de connaître ce nombre à l’avance pour dimensionner correctement les couches suivantes de votre pipeline d’apprentissage automatique. En Python avec iisignature, on peut le calculer ainsi :

import iisignature
d = 4  # dimensions du chemin
m = 3  # profondeur
n_features = iisignature.siglength(d, m)
print(f"Features après signature : {n_features}")  # 4 + 16 + 64 = 84

Préparation du chemin

La manière dont vous préparez votre chemin (choix des dimensions à inclure) est aussi importante que la profondeur elle-même :

• Inclure le temps comme dimension est presque toujours recommandé.
• L’augmentation lead-lag (ajouter les intégrales cumulées) améliore généralement les performances, en particulier pour les données univariées.
• Normaliser chaque dimension avant calcul est essentiel pour la stabilité numérique.

Avantages et Limites

Avantages

1. Invariance au reparamétrage temporel : Fonctionne naturellement avec des données irrégulièrement échantillonnées, sans interpolation ni imputation.
2. Transformation déterministe : Pas de phase d’apprentissage pour la signature elle-même. Calculable sur n’importe quel chemin.
3. Richesse informationnelle : Encode les interactions d’ordre supérieur entre variables, bien au-delà des statistiques descriptives classiques.
4. Efficacité computationnelle : Le calcul de la signature est très rapide (algorithme linéaire en la longueur du chemin), grâce à des implémentations optimisées comme iisignature.
5. Compatibilité universelle : La signature est simplement un vecteur de nombres réels. On peut l’utiliser avec n’importe quel modèle supervisé : régression linéaire, SVM, forêts aléatoires, réseaux de neurones, etc.
6. Base théorique solide : Fondée sur la théorie des chemins rugueux de Terry Lyons, la signature bénéficie de propriétés mathématiques rigoureusement démontrées.
7. Robustesse aux données manquantes : Contrairement aux RNN/LSTM, le Signature Transform n’est pas perturbé par des observations manquantes, puisqu’il opère sur le chemin géométrique global plutôt que sur une séquence discrète.

Limites

1. Malédiction de la dimensionnalité : La dimension des signatures croît exponentiellement avec la profondeur m. Pour d=5 et m=5, on obtient 3905 features — ce qui nécessite beaucoup de données d’entraînement.
2. Perte de l’échelle temporelle : L’invariance au reparamétrage est à double tranchant : si la vitesse d’évolution est informative (par exemple, un mouvement rapide vs. lent), la signature standard la perd. Des variantes comme la path signature avec le temps comme dimension atténuent ce problème.
3. Pas conçu pour la prédiction séquentielle : Le Signature Transform produit une représentation globale du chemin entier. Il n’est pas adapté à la prédiction pas-à-pas (comme la traduction automatique ou le forecasting pur) sans adaptations spécifiques (signatures de fenêtres glissantes).
4. Interprétabilité partielle : Bien que chaque coefficient ait une signification mathématique, l’interprétation d’un coefficient d’ordre 3 ou 4 dans un contexte applicatif concret peut être difficile.
5. Sensibilité au bruit à haute fréquence : Les signatures d’ordre élevé peuvent amplifier le bruit de mesure. Un lissage préalable des données est souvent nécessaire.

Cas d’Usage

1. Données financières irrégulières

En finance quantitative, les transactions ne se produisent pas à intervalles réguliers. Certains moments voient une activité intense (ouverture/fermeture des marchés, annonces économiques), tandis que d’autres sont calmes. Le Signature Transform est naturellement adapté à cette irrégularité.

Application concrète : Prédiction de la direction des prix à partir de données de carnet d’ordres (order book). Les chercheurs (notamment les travaux de Lyons, Bayer et al.) ont montré que les signatures des trajectoires de prix et de volumes permettent de détecter des motifs de trading subtils, surpassant les approches basées sur des rendements à fréquence fixe.

Pourquoi la signature excelle ici : Les motifs de microstructure de marché — comme les séquences d’ordres limites et de marché, les déséquilibres temporaires entre acheteurs et vendeurs — sont fondamentalement des motifs géométriques dans l’espace (prix, volume, temps). La signature les capture naturellement.

2. Reconnaissance de gestes (Gesture Recognition)

La reconnaissance de gestes à partir de données de capteurs inertiels (accéléromètres, gyroscopes) est un problème classique où le Signature Transform montre d’excellentes performances.

Application concrète : Un bracelet connecté enregistre l’accélération selon trois axes ($a_x, a_y, a_z$) lors de gestes de la main. Chaque geste (poing levé, main ouverte, rotation) correspond à un chemin différent dans $\mathbb{R}^3$. La signature de ce chemin encode la dynamique complète du geste — sa forme, sa vitesse, ses transitions — permettant une classification robuste.

Pourquoi la signature excelle ici : Les gestes du même type peuvent être exécutés à des vitesses différentes (invariance au reparamétrage), mais produiront la même signature. Cette propriété d’invariance est exactement ce dont on a besoin pour la reconnaissance de gestes.

3. Classification de mouvements humains

Au-delà de la reconnaissance de gestes discrets, le Signature Transform s’applique à la classification de mouvements continus : marche, course, montée d’escaliers, etc.

Application concrète : Un smartphone dans la poche enregistre les données de l’accéléromètre pendant la journée. En découpant les données en fenêtres et en calculant la signature de chaque fenêtre, on peut classifier le type d’activité (assis, debout, marche, course, vélo) avec une grande précision, même avec des fréquences d’échantillonnage variables (le téléphone peut réduire la fréquence du capteur pour économiser la batterie).

Avantage spécifique : Contrairement aux approches basées sur des caractéristiques statistiques manuelles (moyenne, écart-type, énergie spectrale), la signature capture automatiquement les interactions complexes entre les trois axes de l’accéléromètre, y compris les effets d’ordre supérieur qui seraient difficiles à concevoir manuellement.

4. Médecine et capteurs physiologiques

L’analyse de signaux physiologiques — électrocardiogramme (ECG), électroencéphalogramme (EEG), glycémie continue — implique souvent des données irrégulières (capteurs mal positionnés, artefacts de mouvement, mesures manquantes). Le Signature Transform offre une alternative robuste aux méthodes classiques.

Application concrète : Classification d’anomalies cardiaques à partir de signaux ECG. Chaque battement cardiaque est un chemin dans l’espace des dérivations ECG. La signature du chemin capture la morphologie complète de l’onde P-QRS-T, incluant les interactions temporelles entre les différentes phases du cycle cardiaque. Des travaux récents ont montré que les signatures surpassent les approches basées sur des caractéristiques extraites manuellement pour la détection d’arythmies.

Autre exemple : Prédiction d’épisodes hypoglycémiques à partir de données de capteurs de glycémie en continu (CGM). Les signatures des trajectoires de glucose sur les dernières heures capturent les dynamiques temporelles complexes de la glycémie, permettant une prédiction anticipée des chutes de sucre.

Voir aussi

• Maîtriser les Arrangements Maximaux en Python : Guide Complet et Astuces pour Développeurs
• Trouver la Médiane d’un Flux de Données en Python – Question d’Entretien