Python · FunctionalMH op GitHub

Het probleem

De meeste stationariteitstoetsen zijn gebouwd voor ééndimensionale reeksen en één specifiek parametrisch model. Een unit-root- toets op een AR(1), bijvoorbeeld. Dat werkt niet meer zodra het echte proces niet-lineair of multidimensionaal is. Het verkeerde model fitten en dat model dan toetsen op een unit root zegt heel weinig over het werkelijke proces.

Dit project gaat een andere weg op. Het bouwt een nonparametrische toets die werkt voor een brede klasse van multidimensionale Itô-diffusies, zonder vooraf een parametrische drift- of diffusiefunctie te veronderstellen. Dit is uitgegroeid tot de open-source bibliotheek FunctionalMH, geschreven voor mijn masterscriptie (Testing Multidimensional Diffusion Processes for Stationarity, VU Amsterdam, begeleid door Eric Beutner en Yicong Lin) in Econometrie en Operationele Research.

De setting: een \(d\)-dimensionaal Itô-diffusieproces \((S_t)_{t\ge0}\), met toestandsruimte \(\mathbb{R}^d\), gegeven als de sterke oplossing van \[S_0 = S, \qquad \mathrm{d}S_t = b(S_t)\,\mathrm{d}t + \sigma(S_t)\,\mathrm{d}W_t, \qquad t \ge 0,\] waarbij \(b\) de drift is, \(\sigma\) de diffusiecoëfficiënt, en \(W\) een \(d\)-dimensionale Brownse beweging. Je observeert één traject van \(S\), bemonsterd op discrete tijdstippen. Je kent \(b\) of \(\sigma\) niet. De vraag: is \(S\) stationair?

Drie voorwaarden laten de toets werken. Ten eerste voldoen \(b\) en \(\sigma\) aan Lipschitz- en lineaire-groei- voorwaarden, zodat er een unieke, niet-explosieve oplossing bestaat. Ten tweede is de diffusiecoëfficiënt uniform elliptisch: het proces beweegt met vergelijkbare variantie in elke richting, geen richting is gedegenereerd. Dat sluit cyclische paden uit en houdt het proces aperiodiek. Ten derde is het proces Harris-recurrent: elk gebied met positieve maat wordt oneindig vaak bezocht. Dat garandeert dat er een invariante maat bestaat, en het dwingt de occupation measure van het proces, een lopende telling van hoe lang het proces al in de buurt van een bepaald punt heeft doorgebracht, om onbegrensd te groeien. Die groeisnelheid is wat de toets- statistiek daadwerkelijk meet. Samen bestrijken deze drie voorwaarden een brede klasse financiële en fysische diffusiemodellen, terwijl randgevallen zoals Brownse beweging met drift worden uitgesloten, die slechts het grootste deel van zijn toestandsruimte eindig vaak bezoekt.

Hoe de toets werkt

Het centrale resultaat, van Darling & Kac (1957) en aangescherpt door Lazić & Sandrić (2021) en Lee & Trutnau (2022): voor een Harris-recurrente, uniform elliptische diffusie is stationariteit equivalent aan de occupation measure die lineair groeit in de tijd. Een niet-stationair proces groeit juist sublineair. Dus in plaats van een parametrische hypothese over drift of mean reversion te toetsen, stelt de toets een eenvoudigere vraag. Bezoekt het proces zijn eigen toestandsruimte opnieuw met een lineair tempo, of trager?

Om daar een getal van te maken, vergelijkt de toets twee schatters van de diffusiematrix. Beide zijn consistent of het proces nu stationair is of niet, maar ze bereiken dat met een verschillende snelheid.

  • Een time-domain-schatter: een lokaal, EWMA-achtig gemiddelde van gekwadrateerde increments in een krimpend venster rond een vast tijdstip. De convergentiesnelheid hangt niet af van stationariteit, omdat hij alleen kijkt naar data die dicht in de tijd bij het geschatte punt ligt.
  • Een state-domain-schatter: een Nadaraya–Watson-kernelregressie die gekwadrateerde increments middelt over elke observatie dicht bij een bepaalde toestand, ongeacht wanneer die plaatsvond. De snelheid hangt af van de occupation measure bij die toestand. Hij convergeert sneller zodra het proces meer tijd in de buurt heeft doorgebracht, en dat gebeurt alleen met een lineair tempo als het proces stationair is.

Dit is hetzelfde idee als een Durbin–Wu–Hausman-toets: twee schatters van hetzelfde dat overeenkomen onder de nulhypothese en uiteenlopen onder het alternatief. Hier is de nulhypothese dat \(S\) stationair is. Onder de nulhypothese convergeert het gestandaardiseerde verschil tussen de twee schatters naar een Gaussische reeks met gemiddelde nul. Onder het alternatief loopt het uiteen, omdat de state-domain-schatter vertraagt terwijl de time-domain- schatter zijn gebruikelijke snelheid aanhoudt.

Omdat de diffusiematrix op elk punt langs het traject geschat wordt, levert deze vergelijking niet één toetsstatistiek op. Het levert een hele reeks ervan op, ruwweg één per geobserveerd tijdstip. De toets heeft één getal nodig om op basis van die reeks een beslissing te nemen, en leent daarvoor een idee uit de extreme-waardetheorie. Onder de nulhypothese gedraagt de reeks zich als een stationair Gaussisch proces, en het lopende maximum van zo'n proces heeft een bekende, gesloten Gumbel-achtige limiet. De toets verwerpt stationariteit als het geobserveerde lopende maximum die limiet overschrijdt. Geen bootstrap, geen gesimuleerde kritieke waarden, gewoon een analytische grens.

Hoe de code georganiseerd is

Let op. Alles hieronder is geschreven voor bivariate processen (\(d=2\)). De theorie hierboven geldt voor elke dimensie \(d\), en models/processes.py bevat simulators in andere dimensies ter referentie, maar de schatter en toetsstatistiek in testing/kernel_test.py zijn specifiek gebouwd rond \(2\times2\)-diffusiematrices. De vech-halfvectorisatie, de matrix-vierkantswortel-inverse, en de dichtheidsschatting binnen de state-domain-smoother gaan allemaal uit van \(d=2\).

Het package staat onder src/mht/. testing/kernel_test.py bevat de kern van de toets: Kernel, KernelTest, Simulator, TestPlotter. testing/hypothesis.py voegt MultipleHypTest toe, een Benjamini–Hochberg/Yekutieli FDR-control-alternatief voor de running-maximum-aanpak hieronder. models/processes.py bevat vier SDE- simulators, waaronder een bivariate gecorreleerde diffusie met een Milstein-schema en een expliciete correctieterm voor de polynomiale diffusiecoëfficiënt. io/reader.py laadt voorberekende simulatie-CSV's.

Alles loopt via één object, KernelTest. Je geeft het een traject en twee configuratie- dictionaries, en het brengt je in vier stappen van ruwe data naar een verwerpingsbeslissing: de data voorbereiden, een kernel en bandbreedte kiezen, de twee schatters berekenen, en dan reduceren naar één toetsstatistiek. De walkthrough hieronder volgt die vier stappen in volgorde, met de daadwerkelijke code bij elke stap.

Stap 1. Het traject laden

KernelTest is een dunne, stateful container. Geef het een bivariaat traject, gesimuleerd met BivariateOUProcess/BivariateCorrelatedBM of ingelezen uit een CSV, en het slaat de configuratie voor de twee schatters op. Er wordt nog niets berekend, de schattingen worden alleen gevuld zodra je de methoden in stap 3 en 4 aanroept.

class KernelTest:
    """Kernel-based test for time-homogeneity of the diffusion matrix.

    Compares a state-domain smoother against a time-domain smoother of the
    integrated diffusion matrix. Under H0 (time-homogeneous diffusion) the
    standardised difference converges to a Gaussian process whose running
    maximum has a known Gumbel-type limit distribution.
    """

    def __init__(
        self,
        data: pd.DataFrame,        # columns ['process 1', 'process 2']
        kernel_params: dict,       # {'bandwidth', 'n', 'T', 'kernel'}
        time_params: dict,         # {'bandwidth', 'n', 'T'}
        disable: bool = False,     # suppress tqdm progress bars
    ) -> None:
        self.data = data
        self.kernel_params = kernel_params
        self.time_params = time_params
        self.disable = disable
        self.kernel_estimates: dict = {}
        self.time_estimates: dict = {}

Als de data gesimuleerd is op een raster van \(n\) observaties over horizon \(T\), is het effectieve bemonsterings- interval \(\Delta_n = T/n\). Dat is het getal waarop elke bandbreedte hieronder is afgestemd.

Stap 2. Een kernel en bandbreedte kiezen

De state-domain-smoother heeft een kernel en een bandbreedte nodig. De standaardkernel is Kernel.BaseKernel, een gewone boxcar: gewicht 1 binnen de bandbreedte, 0 daarbuiten. De time-domain- smoother heeft zijn eigen, apart afgestemde bandbreedte nodig. Beide volgen de bijna-optimale snelheden van Bandi & Moloche (2018), zodat je niet voor elke dataset handmatig een nieuwe constante hoeft af te stemmen; Simulator zoekt ze op in een tabel, gesleuteld op horizonlengte.

class Kernel:
    """Kernel functions for the state-domain (Nadaraya-Watson) smoother."""

    def __init__(self, *, kernel_params: dict) -> None:
        self.kernel_params = kernel_params

    def BaseKernel(self) -> Callable:
        """Boxcar/indicator kernel, K(x) = 1{|x| <= h}."""
        def k(x: np.ndarray) -> np.ndarray:
            return np.where(np.abs(x) <= 1, 1.0, 0.0)
        return k

Stap 1 en 2 samen, zo ziet het opzetten van een toets er in de praktijk uit. De bandbreedte hier volgt de bijna-optimale snelheid \(h_{n,T} = C/(n^{1/6}\log n)\) van Bandi & Moloche (2018), met de constante \(C\) éénmalig afgestemd per horizonlengte.

from mht.testing.kernel_test import KernelTest, Kernel

n, T = 3000, 150.0
bandwidth = np.sqrt(3) * 6 / (n ** (1 / 6) * np.log(n))

test = KernelTest(
    data=trajectory,                                  # DataFrame, shape (n, 2)
    kernel_params={
        'bandwidth': bandwidth,
        'n': n, 'T': T,
        'kernel': Kernel.BaseKernel,
    },
    time_params={'bandwidth': 100 * T / n, 'n': n, 'T': T},
    disable=True,
)

Stap 3. Beide schatters berekenen

Drie aanroepen doen het echte werk van deze stap. time_domain_smoother bouwt de EWMA-gewogen time-domain-schatter. state_domain_smoother bouwt de Nadaraya–Watson state-domain- schatter, optioneel met een kerneldichtheidsschatting van de toestand in plaats van een ruwe occupation count. gauss neemt vervolgens het gestandaardiseerde verschil tussen de twee, via een matrix-vierkantswortel- inverse van hun gecombineerde covariantie. Als die matrixinversie numeriek faalt, valt het terug op NaN in plaats van te crashen, goed om te weten, want een mislukte inversie zou anders kunnen lijken op bewijs tegen de nulhypothese.

test.time_domain_smoother(lamb=0.94)     # EWMA time-domain estimator ĉ_TD
test.state_domain_smoother(dist=False)   # Nadaraya-Watson state-domain estimator ĉ_SD
test.gauss()                             # standardised difference, stored in test.gaussian

Voordat je enige toetsstatistiek berekent, plot de twee schattingen tegen elkaar. Ze volgen dezelfde diffusiecoëfficiënt, alleen vanuit andere data, dus elk echt structureel gat tussen beide is precies waarvoor de toets later gebouwd is om op te pikken. De twee figuren hieronder draaien dit op twee gesimuleerde bivariate trajecten: een stationair Ornstein–Uhlenbeck-proces, en een tijd-inhomogene diffusie waarbij de werkelijke volatiliteit in de tijd verschuift.

State-domain versus time-domain volatility estimate, one panel per process component, for a simulated stationary bivariate Ornstein-Uhlenbeck process

Stationair bivariaat OU-proces, \(T=150\), \(n=3000\), één panel per component. De twee schatters volgen elkaar nauwgezet gedurende de hele reeks. Precies wat de nulhypothese voorspelt.

State-domain versus time-domain volatility estimate, one panel per process component, for a simulated time-inhomogeneous bivariate diffusion

Tijd-inhomogene bivariate diffusie, dezelfde \(T\) en \(n\). De state-domain-smoother bundelt observaties over het hele traject, dus schiet hij voorbij de time-domain-smoother zodra de werkelijke diffusiecoëfficiënt in beweging is.

Stap 4. Reduceren naar één toetsstatistiek

gauss laat je achter met een reeks gestandaardiseerde verschillen, één per geobserveerd tijdstip, niet één enkel getal. transform_1D_gauss is de laatste stap: hij comprimeert die reeks tot een scalair lopend maximum en koppelt dat aan de analytische Pickands–Berman-Gumbel-grens op een gegeven betrouwbaarheids- niveau. Als het lopende maximum de grens overschrijdt, verwerpt de toets stationariteit. Er is geen simulatie of bootstrap nodig voor de kritieke waarde, die komt rechtstreeks uit de extreme-waardetheorie.

def transform_1D_gauss(self, alpha: float = 0.95) -> tuple:
    """Reduce the Gaussian process to a scalar running maximum and its
    Gumbel-type critical bound at confidence level alpha."""
    x = np.log(1 / np.log(1 / alpha))
    n = len(self.gaussian)
    a_n = [np.sqrt(2 * np.log(z)) for z in range(1, n + 1)]
    b_n = [
        np.sqrt(2 * np.log(z))
        - np.log(np.pi * np.log(z)) / (2 * np.sqrt(2 * np.log(z)))
        for z in range(1, n + 1)
    ]
    bound = [np.nan] + [(x / a_n[i]) + b_n[i] for i in range(1, n)]
    scalar_gauss = [float(np.sum(g) / np.sqrt(3)) for g in self.gaussian]
    return bound, scalar_gauss

Aanroepen en het resultaat controleren is één regel elk.

bound, z = test.transform_1D_gauss(alpha=0.95)
rejects = running_maximum(z)[-1] > bound[-1]

Hier is die check op dezelfde twee trajecten uit stap 3. Op het stationaire proces zakt het lopende maximum vroeg onder de kritieke grens en blijft het daar. Op het tijd-inhomogene proces overschrijdt het de grens binnen de eerste paar honderd observaties en blijft het stijgen, omdat het gestandaardiseerde verschil tussen de twee schatters nooit stabiliseert zodra de werkelijke diffusiecoëfficiënt in beweging komt.

Running maximum test statistic for the stationary Ornstein-Uhlenbeck process, staying below the Gumbel critical bounds at every confidence level

Het gestandaardiseerde Gaussische proces \(Z_t\) (grijs), zijn empirische lopende maximum \(\phi_j\) (rood), en de Pickands–Berman kritieke grens op vier betrouwbaarheidsniveaus. Het lopende maximum overschrijdt zelfs de losste (50%) grens niet, dus verwerpt de toets stationariteit niet.

Running maximum test statistic for the nonstationary time-inhomogeneous diffusion, sharply exceeding all Gumbel critical bounds

Dezelfde constructie op de tijd-inhomogene diffusie. Het lopende maximum doorbreekt elke grens binnen de eerste paar honderd observaties en komt niet meer terug. Een duidelijke verwerping van stationariteit.

Waarom de code zo opgesplitst is

Elk onderdeel is om een reden apart gehouden. time_domain_smoother en state_domain_smoother blijven gescheiden methoden, geen gecombineerde schatter, omdat ze verschillende hoeveelheden data gebruiken met verschillende snelheden. Ze apart houden maakt het ook makkelijk om later een andere smoother in te wisselen, zonder de rest van de pipeline aan te raken. gauss is zijn eigen methode omdat het de ene stap is die een numeriek fragiele matrixinversie doet, dus door hem te isoleren wordt dat faalmodus makkelijk te herkennen. transform_1D_gauss is apart gehouden van gauss omdat het kiezen van een betrouwbaarheids- niveau en reduceren tot een lopend maximum een modelkeuze is, los van het schatten van het gestandaardiseerde verschil zelf. Simulator stuurt Monte Carlo-replicatie aan en kiest automatisch bandbreedtes, zodat een simulatiestudie geen handmatige afstemming nodig heeft bij elke run. TestPlotter leidt af van KernelTest om de plotmethoden toe te voegen die gebruikt zijn voor de figuren hierboven, zodat een plot altijd weerspiegelt welke configuratie het onderliggende testobject heeft opgeleverd. Numerieke vangnetten lopen overal doorheen: fragiele matrixinversies geven NaN terug in plaats van een fout te gooien, en een caching-decorator valt netjes terug zodra hem iets onhashable wordt aangeboden, zoals een DataFrame.

Testen en validatie

tests/test_processes.py en tests/test_kernel_test.py zijn smoke-tests. Ze controleren dat gesimuleerde paden eindig en correct van vorm zijn, en dat de pipeline end-to-end draait en een eindige grens teruggeeft. Ze controleren niet de daadwerkelijke verwerpingspercentages. simulations/ bevat voorberekende CSV's van Gaussische-procespaden onder de nulhypothese, bij twee steekproefgroottes, gebruikt voor een batch- verwerpingspercentagestudie van de toets zelf.

In de eigen simulatiestudie van de scriptie komt de toets dicht bij het nominale verwerpingspercentage van 5% terecht op een stationair bivariaat Ornstein–Uhlenbeck-proces naarmate de steekproef groeit. Hij verwerpt een niet-stationaire planaire Brownse beweging snel. Op een tijd-inhomogene bivariate diffusie signaleert hij niet-stationariteit correct, maar met een echte beperking: de power daalt naarmate \(T\) groeit terwijl het bemonsteringsinterval \(\Delta_n\) vast wordt gehouden. Dat gebeurt omdat het proces, bekeken op elke enkele vaste tijdschaal, er lokaal uit begint te zien als een stationair Ornstein–Uhlenbeck-proces. Het is dezelfde waarschuwing als uit de theoriesectie hierboven: de running-maximum-benadering heeft een voldoende grote steekproef nodig om de extreme-waarde-asymptotiek daadwerkelijk te laten gelden.

Repository-structuur

src/mht/
    testing/
        kernel_test.py        # KernelTest, Simulator, TestPlotter
        hypothesis.py         # MultipleHypTest, LaTeXTable
    models/
        processes.py          # BivariateOUProcess, BivariateCorrelatedBM, ...
    io/
        reader.py             # Reader class for simulation CSV files
    viz/                      # TestPlotter re-exported here
    utils/
        decorators.py
simulations/                  # Pre-computed CSV simulation results
notebooks/
    example.ipynb
tests/
    test_processes.py
    test_kernel_test.py

Vereist Python ≥ 3.10. Bevat ook BH/BY FDR-procedures als alternatieve multiple-hypothesis-baseline voor simulatiestudies.