Updating the Volume Curve Intraday: Does Adaptive Forecasting Actually Help?

In TWAP, VWAP en POV hebben we alle drie de planners één voor één laten draaien op 90 dagen BTCUSDT L2-herhaling en kwamen we tot een conclusie die opzettelijk als een open wond werd gelaten: in crypto is de volumecurve de zwakste schakel van de pijplijn, niet de slicing. Dat artikel verscheepte met opzet de eenvoudige versie – een op mediaan gebaseerde curve van dag van de week x tijd van de dag, wekelijkse refit, statisch gehouden gedurende de handelsdag. En het ontdekte dat de volledige voorsprong van VWAP op TWAP de voorspelde kwaliteit is: afhankelijk van de gerealiseerde volumecurvefout verslaat VWAP TWAP met grofweg 4 basispunten op het best voorspelde terciel van dagen, en de kloof stort in in ruis op het slechtste terciel.

Dat resultaat impliceert een specifiek, falsifieerbaar vervolg. Als VWAP alleen maar wint op dagen waarop de curve toevallig goed was, dan zou een voorspeller die zichzelf corrigeert naarmate de dag zich ontvouwt enkele van de slechte dagen in goede moeten omzetten. Of dat zou niet moeten – en de interessante versie van dit artikel is die waarin dat niet het geval is, omdat het slechte begrip in crypto cascadedagen en nieuwsdagen zijn, en dat zijn precies de dagen waarop de eerste twee uur van het waargenomen volume het minst informatief zijn over de volgende twee.

Dit artikel implementeert de intraday-updater, voert deze uit tegen hetzelfde harnas en rapporteert de IS-delta versus de statische curve – met de verdeling en het laatste kwartielgetal, niet alleen het gemiddelde.

Wat wordt er getest

De statische curve is een prior: een vaste vector $u = \{u_1, \ldots, u_B\}$ van verwachte volumefracties per emmer, offline geschat. De adaptieve versie beschouwt het als een voorafgaande update. Na $c$ emmers zijn verstreken en u hebt de werkelijke volumes waargenomen $V_1, \ldots, V_c$, heb je twee stukjes nieuwe informatie die de statische curve weggooit:

1. Een niveauschatting. Als de prior emmers zegt $1..c$ fractie had moeten dragen $\sum_{i \le c} u_i$ van de dag en ze droegen $\sum_{i\le c} V_i$ eenheden, het impliciete totaal van een hele dag is $\hat{V} = \sum_{i \le c} V_i \big/ \sum_{i \le c} u_i$. Dit is een signaal voor vandaag-is-een-zware-dag/vandaag-is-een-dode-dag en is beschikbaar vanaf de eerste bucket.
2. Een vormcorrectie. Als de gerealiseerde vorm van de verstreken buckets systematisch afwijkt van de eerdere vorm, kunnen de resterende buckets ook afwijken – maar alleen als intraday-volumecurvefouten binnen de dag autocorreleerd zijn, wat op zichzelf een empirische vraag is en geen aanname die we gratis mogen doen.

De onderstaande implementatie gebruikt (1) volledig en (2) helemaal niet: het renormaliseert de onaangeroerde voorafgaande staart naar het bijgewerkte totaal. Dat is de conservatieve versie, en het is het juiste eerste experiment, want als de pure niveau-update al het grootste deel van de beschikbare delta vastlegt, is de vormmachine een ongerechtvaardigde complexiteit.

import numpy as np
from typing import Optional


class AdaptiveVolumePredictor:
    """
    Bayesian-style adaptive volume profile predictor.

    Combines a prior (the offline day-of-week x time-of-day curve)
    with volume observed so far today to produce an updated forecast
    for the remaining buckets.
    """

    def __init__(self, historical_profiles: np.ndarray):
        """
        Args:
            historical_profiles: shape (n_days, n_buckets), each row sums to 1.0.
                Use the median-based, day-of-week-conditioned curve from the
                TWAP/VWAP/POV article -- a pooled mean curve is misspecified
                and will make the adaptive version look better than it is by
                giving it a weaker baseline to beat.
        """
        self.prior_profile = np.median(historical_profiles, axis=0)
        self.prior_profile /= self.prior_profile.sum()
        self.prior_iqr = np.subtract(*np.percentile(historical_profiles, [75, 25], axis=0))
        self.n_buckets = len(self.prior_profile)

    def predict(
        self,
        observed_volumes: np.ndarray,
        current_bucket: int,
        total_volume_estimate: Optional[float] = None,
    ) -> np.ndarray:
        """
        Predict absolute volume for every bucket: realized values for elapsed
        buckets, forecasts for the remainder.

        Args:
            observed_volumes: actual volumes in buckets 0..current_bucket-1
            current_bucket: index of the current bucket (0-based)
            total_volume_estimate: external ADV estimate (optional prior on level)
        """
        profile = np.zeros(self.n_buckets)

        if current_bucket == 0:
            base = total_volume_estimate if total_volume_estimate else 1.0
            return self.prior_profile * base

        profile[:current_bucket] = observed_volumes[:current_bucket]
        observed_total = observed_volumes[:current_bucket].sum()

        expected_fraction_so_far = self.prior_profile[:current_bucket].sum()
        if expected_fraction_so_far > 0.01:
            implied_total = observed_total / expected_fraction_so_far
        else:
            implied_total = observed_total * self.n_buckets

        if total_volume_estimate:
            w_obs = expected_fraction_so_far
            implied_total = w_obs * implied_total + (1 - w_obs) * total_volume_estimate

        remaining_prior = self.prior_profile[current_bucket:]
        remaining_sum = remaining_prior.sum()
        if remaining_sum > 0:
            remaining_volume = max(0.0, implied_total - observed_total)
            profile[current_bucket:] = remaining_prior / remaining_sum * remaining_volume

        return profile

Twee details in die code dragen het experiment over. De prior is de mediaan-curve die is gebaseerd op de dag van de week, en niet op een gepoold gemiddelde. Waarom dat van belang is in een markt waar één liquidatiecascade in tien minuten 15% van het dagvolume kan bedragen, zie het volume-curve-gedeelte van het VWAP-artikel. En de niveau-update is verkleind naar een externe ADV-schatting met een gewicht dat gelijk is aan de verstreken voorafgaande fractie, omdat in de eerste bucket implied_total is één waarneming gedeeld door een getal nabij nul. Een niet-gekrompen updater doet zijn slechtste werk precies op het moment dat hij nog de meeste dagen te verpesten heeft.

Harnas

Identiek aan de uitvoering van TWAP/VWAP/POV, dus de cijfers zijn regel voor regel vergelijkbaar:

• Instrument/data: BTCUSDT eeuwigdurend, 90 dagen L2-herhaling (top 20 niveaus, 100 ms) plus de handelstape. UTC overal; financieringstijdstempels gemarkeerd.
• Ouderbestellingen: 500, horizon $T = 4$h, omvang 0,75% van de ADV van de volgende 30 dagen, koopkant, beslissingsprijs = midden bij start. Dezelfde willekeurige starttijden als de gepubliceerde run.
• Arms: (A) VWAP op de statische wekelijkse-refitcurve — de gepubliceerde basislijn; (B) VWAP op dezelfde eerdere datum met update binnen de dag; (C) TWAP als vloer.
• Metrieken: IS in bps van de beslissingsprijs, inclusief kosten, versus aankomst - gerapporteerd als gemiddelde, mediaan, standaarddeviatie, 95e percentiel en IS van het laatste kwartiel van elke ouder. VWAP-ontsporing wordt alleen als diagnose geregistreerd, nooit als scorebord; de benchmarksectie van het VWAP-artikel toont een uitgewerkt geval waarbij VWAP-slippage en aankomst twee algoritmen in tegengestelde volgorde rangschikken. De volledige IS-decompositie, inclusief de term opportuniteitskosten, volgt implementation shortfall and TCA.

Resultaten

Helpt het waar het nodig is?

Het kopgemiddelde is hier het minst interessante getal. Het gepubliceerde resultaat stelde vast dat de VWAP-TWAP-kloof monotoon is wat betreft de gerealiseerde volumecurvefout, dus de adaptieve arm moet op dezelfde manier worden gescoord: verdeel de 90 dagen in tercielen door $L_1$ afstand tussen de statische voorspelling en de gerealiseerde bucketvolumes, en rapporteer vervolgens de adaptieve-minus-statische IS-delta binnen elk terciel.

De twee uitkomsten zijn beide publiceerbaar en betekenen tegenovergestelde dingen:

• Delta geconcentreerd in het goede tercile. De updater verfijnt dagen die al gemakkelijk waren. Het netto-effect op de kostenverdeling is cosmetisch; de staart – dat is wat een alfa-gedreven ouder met een harde horizon feitelijk betaalt – is onveranderd. Dit zou betekenen dat de intraday-updater niet de oplossing is voor de zwakste schakel, en dat de vormcorrectie- en cross-asset-routes de volgende punten zijn.
• Delta geconcentreerd in het slechte terciel. De updater doet waarvoor hij is gebouwd: het opvangen van de cascade- en nieuwsdagen waarop de statische curve het meest fout is. Dit is de uitkomst die de toegevoegde status in de uitvoeringslus zou rechtvaardigen.

Een negatief resultaat is het verwachte resultaat en het is de moeite waard om dit duidelijk te melden. Het mechanisme dat crypto-volumecurves moeilijk maakt – een cascade is een regimebreuk, geen niveauverschuiving – is precies het mechanisme dat een voorspeller van niveau-updates verslaat: tegen de tijd dat de verstreken buckets je vertellen dat het vandaag zwaar is, kan het zware deel voorbij zijn. Zie het eerlijke negatieve voor waarom deze blog deze publiceert.

Boekhelling: voegt het iets toe?

Eén functie in de conceptset wordt nergens anders op deze blog behandeld: book slope, hoe snel de cumulatieve diepte zich ophoopt als je weggaat van de aanraking. Fit $\text{CumVol}(d) = \alpha + \beta d$ over de bovenkant $K$ niveaus; groot $\beta$ betekent dat de diepte geconcentreerd is bij aanraking, klein $\beta$ betekent dat het dun over het boek is verspreid.

def book_slope(prices: np.ndarray, volumes: np.ndarray, mid: float) -> float:
    """Slope of cumulative depth vs. distance from mid. One side only."""
    distances = np.abs(prices - mid)
    return float(np.polyfit(distances, np.cumsum(volumes), 1)[0])

De enige versie van deze bewering die de moeite waard is, is een afgemeten versie: voegt toe book_slope met de bestaande functieset de volumevoorspelling, of de resulterende IS, voorbij een AR/EWMA-basislijn verplaatsen? Het spread modeling artikel zet de standaard: rapporteer vaardigheid boven een triviale basislijn met de aangegeven horizon, omdat deze reeksen worden gedomineerd door persistentie en een kop R² meet meestal autocorrelatie.

Wat dit artikel opzettelijk niet opnieuw afleidt

Alles hieronder staat al uitgebreider op de blog, en als je het hier opnieuw uitlegt, ontstaat er alleen maar een zwakkere tweede versie:

• Liquiditeitsmeting. Roll's schatter (met de ondertekende root-fix en de prijs-eenheden-vs-rendementsval) en Kyle's lambda: spread modeling with machine learning. Kyle's lambda is ook gekalibreerd op echte Binance aggTrades als de permanente impactcoëfficiënt in Almgren-Chriss. Walk-the-book sweep-kosten: slippage- en kostenmodellen.
• Orderboekfuncties. Het gewogen midden (dat niet de microprijs van Stoikov is – die is martingaal-gecorrigeerd), boekonbalans op meerdere niveaus, OFI en de volledige LOB-functietaxonomie: DeepLOB en spread modeling.
• Intraday-patronen. De aandelen-U-vorm is het verkeerde model voor een markt zonder afsluiting; de cryptosessie/financiering/wekelijkse structuur die deze vervangt, plus het dag-van-week × tijd-van-dag-raster, staat in het VWAP-artikel. Cyclische tijd-van-dag-codering bevindt zich in de functietabel van spread Articles.
• Geplande evenementen. Deribit 08:00 UTC vervalt, Amerikaanse macro om 12:30/14:00 UTC, CME-schikkingen – behandel ze als dummies in plaats van ze de basislijncurve te laten vervuilen; de concrete cryptokalender staat in het VWAP-artikel. De adaptieve updater hierboven is geen een gebeurtenishandler en er mag niet om gevraagd worden om er een te zijn.
• Modellen. Verhoging van het verloop met opgeschoonde walk-forward CV onder embargo (een gewone TimeSeriesSplit lekken over het overlappende doel in het voorwaartse venster) bevindt zich in spread modeling; de CNN-LSTM-familie, de inputtensor met 40 functies en 10 niveaus, LOBFrame, en de discussie over de replicatiecrisis staan ​​in DeepLOB. Houd er in het bijzonder rekening mee dat de niveau-as niet vóór de terugkerende laag mag worden ingeklapt.
• De beslissing over de onderliggende volgorde. Passief versus agressief is een berekende break-even $p^* = \delta/(\Pi + \delta)$, geen hardgecodeerde spreaddrempel: tactiek voor uitvoering van onderliggende orders. Het targeten op participatiegraad is endogeen (uw eigen vullingen worden op de tape afgedrukt) en de correctie staat in het [VWAP-artikel] (/en/blog/post/twap-vwap-pov-execution-algorithms).
• Locatiefragmentatie. Slimme orderrouting in crypto, met de TCA-scorekaart per locatie in implementation shortfall.
• Productielatentie. DeepLOB's productiesectie; Merk op dat het verspreide artikel al claims op het gebied van inferentietijd kwalificeert - een LightGBM van 2000 voorspelt in tientallen microseconden vanuit Python, alleen uit één cijfer met een gecompileerde voorspeller.

Tegenstrijdige dynamiek verdient één paragraaf in plaats van een sectie. De weergegeven diepte is deels performatief, en de detectiemechanismen – annuleringssnelheid, snelheid van muuropbouw, gedrag als prijs nadert, gelaagdheid – worden behandeld met een concrete op PIQ gebaseerde methode in [wachtrijpositie en muuranalyse] (/en/blog/post/queue-position-order-book-wall-analysis). De enige delta die dit artikel zou kunnen toevoegen is dat ze worden behandeld als forecaster-inputs: de cancel-to-trade-ratio, de gemiddelde rusttijd bij aanraking en de fractie van de diepte die binnen 100 ms na verschijnen wordt geannuleerd, naast het verstreken-bucket-signaal aan het volumemodel toegevoegd. Of ze vaardigheden toevoegen aan de bestaande functieset is een open meting en geen claim.

Conclusie

De bewering die wordt getest is beperkt en de blog heeft al de voorwaarden geschapen om deze te vervalsen: het VWAP-artikel stelde vast dat het voordeel van VWAP volledig gelegen is in de kwaliteit van de voorspellingen en dat de voorspellingen mislukken op de dagen die het meeste kosten. Een intraday-updater lost dat op, of niet, en het antwoord is een getal in het slechte tercile van een herhaling van 500 ouders.

Wat dit artikel niet doet, is een bps-cijfer aan een productiesysteem koppelen zonder dat er een herhaling achter zit. Beweringen in de vorm van "goed afgestemde liquiditeitsvoorspelling bespaart 2-5 bp, het verschil tussen een Sharpe van 1,5 en 2,0" zijn precies het genre dat deflated Sharpe and multiple testing bestaat om te ontmantelen: zonder bron, zonder voorwaarden, en nooit vergezeld van de verspreiding. Het getal dat hier van belang is, is de IS van het laatste kwartiel op het slechtste terciel van dagen, en dit wordt gemeten of niet gerapporteerd.