16Benchmark Algorithms

Most institutional equity orders are handed to algorithms that promise a benchmark: the day’s volume-weighted price, the arrival price, the close. Each promise is a schedule, and each schedule is only as good as its forecast of the day’s volume. This chapter builds the five classic algorithms on chapter 14’s scheduler interface, forecasts intraday volume three ways, and runs everything in the simulated market to measure how much of an algorithm’s miss against its benchmark is the volume forecast’s fault, what a participation algorithm does to the volume it follows, and how a benchmark can be moved by the order measured against it.

16.1 The algorithms and their benchmarks

The benchmarks are those of One Quant Book 7 (chapters 2, 19 and 23): the volume-weighted average price, the arrival price for implementation shortfall, the closing price. Madhavan’s encyclopaedia entry describes the VWAP as a common benchmark for judging trading and execution, and Kissell’s textbook (2014) catalogues the algorithms brokers built on it. Each algorithm is easy to measure against its own benchmark, and that is the trap: the benchmark is not what the client pays against the price the order met.

In the simulated market (firm.agentmkt on firm.exchsim, a day of 26 one-minute bins whose activity follows a U-shaped curve), each algorithm buys 15 000 shares, about 5% of an ordinary day’s volume, on the same eight days with the same order flow, and each day is also run without it. Prices are in ticks, one cent on a USD 100 stock, so a tick is a basis point; positive numbers are what the buyer paid above the reference. Table 16.1 reports the miss against each algorithm’s own benchmark, how far its buying moved that benchmark (the benchmark with the algorithm minus the same day’s without it), the impact cost (fills against the mid the same day had at the same instants without the algorithm), and the cost against the arrival price.

Three things show. The VWAP algorithm misses the VWAP by 0.6 ticks with a standard deviation of 0.2, the tightest of all; but its own buying raised the day’s VWAP by 2.0 ticks, so the cost it caused, 2.7 ticks of impact, is more than four times its reported slippage. The target-close algorithm “beats” the close by 5.9 ticks because its 4 500-share market-on-close order, crossed against a thin closing book, raised the closing price by 12.6 ticks: it moved its own benchmark. Against the arrival price, the day’s own price moves (a standard deviation of about six ticks) swamp the differences on eight days; only the common-random-number impact cost ranks the algorithms reliably, and there the participation and close algorithms, which trade fastest or in one block, cost the most.

16.2 Forecasting intraday volume

The simulated panel has twenty stocks over 250 days of 26 bins. Each stock has its own U-shaped profile with a run-up into the close; the volume of a bin multiplies the stock’s level by a market factor (persistent from day to day and autocorrelated within the day), a day-level shock, a stock-specific AR(1) deviation within the day, and, on 8% of stock-days, news that makes the volume surge from a random bin and fade over about four bins. These curves are firm.agentmkt’s activity: they scale the rate of its noise traders’ orders and of its liquidity providers’ quotes, and the volume a day prints is its noise traders’ orders, which the simulator draws in advance from the day’s seed. Figure 16.1 shows a stock’s average profile, an ordinary day and a news day.

Five forecasters are compared on the 190 days after a 60-day training period, for every stock:

• the static curve: the average profile of the 60 training days, never updated;
• the rolling profile: the average of the last 20 days’ shares;
• level plus AR: the rolling profile with a model of the day, $\log v_k=\log(\bar V p_k)+\ell+e_k$, where the level $\ell$ lasts all day and the deviation $e_k$ is AR(1); after $k$ bins the level is estimated by generalised least squares from the deviations seen and the last deviation is let fade (Listing 16.1);
• PCA-ARMA: Białkowski, Darolles and Le Fol’s (2008) decomposition of turnover into a common component, extracted by principal component analysis (One Quant Book 4, chapter 22) across the stocks and forecast by its average over the last 20 days, and a stock-specific component forecast by an ARMA model (they also used threshold autoregressions); here AR(1);
• the same, dynamic: the specific component re-forecast after each bin from the last one observed.

    @classmethod
    def fit(cls, history) -> LevelAR:
        h = np.asarray(history, float)
        prof, adv = profile(h), float(h.sum(axis=1).mean())
        dev = np.log(h / (adv * prof))
        lev = dev.mean(axis=1)
        e = dev - lev[:, None]
        rho = float(np.sum(e[:, 1:] * e[:, :-1]) / np.sum(e[:, :-1] ** 2))
        return cls(prof, adv, rho, float(lev.std(ddof=1)), float(e.std(ddof=1)))

    def remaining(self, observed) -> np.ndarray:
        k, base = len(observed), super().remaining(observed)
        if k == 0:
            return base
        y = np.log(np.maximum(np.asarray(observed, float), 1e-9) / (self.adv * self.p[:k]))
        i = np.arange(k)
        cov = self.s_dev**2 * self.rho ** np.abs(i[:, None] - i[None, :])
        w = np.linalg.solve(cov, np.ones(k))
        level = float(w @ y / (w.sum() + 1 / self.s_level**2))   # GLS, shrunk toward zero
        fade = self.rho ** np.arange(1, len(base) + 1)   # e fades, the level stays

A forecast error matters only through what it does to the schedule’s price. Write the schedule’s shares $a_k$ and the day’s volume shares $b_k$, and $D_k=\sum_{i\le k}(a_i-b_i)$ their cumulative difference.

The tracking error $s\sqrt{\sum D_k^2}$ is what Figure 16.2 reports, for a stock with 2% daily volatility, on the 3 800 stock-days of the test period and on the 331 of them (8.7%) whose volume exceeded 1.5 times the stock’s average of the previous 20 days. Konishi (2002) solved the static version of the problem, the slicing that minimises this variance when volume and price are random.

Three lessons. Forecasting shares is hard: the best forecaster’s total error in the day’s shares, $\sum_k|a_k-b_k|$, is still 0.306 (against 0.324 for the static curve), because most of a bin’s deviation is noise nobody can predict. High-volume days cost more, 17.7 basis points of tracking error for the static curve against 13.7 on other days, because their extra volume comes in surges that reshape the day. And updating helps a little on ordinary days (the PCA-ARMA dynamic schedule gives 12.7 against 13.7) but can hurt on the days that matter: its additive AR(1), fitted mostly on quiet days, mistakes a news surge for noise that will revert and ends at 20.6 basis points, worse than not updating. The level-plus-AR model, which separates a day’s level from its transient deviations, is the only one to do better on both kinds of day (13.3 and 17.2). The rolling profile is no better than the static curve here because the simulated profile does not drift; on real data it does.

16.3 VWAP: static and dynamic

The slippage of a buy against the day’s VWAP splits exactly. With $q_k$ shares bought in bin $k$ at an average $f_k$, the bin’s market volume $v_k$ and VWAP $w_k$, $Q=\sum q_k$ and $V=\sum v_k$,

the execution part is what each bin’s child orders paid against that bin’s VWAP (the spread and the impact), the schedule part is the volume forecast’s error priced by the day’s moves. firm_algos.decompose computes both; the tests check that they add up to the slippage to the cent.

        f = static.remaining(np.zeros(0))
        return QTY * f[k] / f.sum()

    def dynamic_schedule(k, total, own, planned):
        f = dyn.remaining(total - own)
        return (QTY - planned) * f[0] / f.sum()
    return static_schedule, dynamic_schedule

Humphery-Jenner (2011) built a dynamic VWAP that lets the schedule react to news during the day. Here both schedules buy 15 000 shares (4.95% of the volume on the ordinary days, 2.5% on the busy ones) on sixteen high-volume and sixteen other stock-days of the simulated panel, in the simulated market, with the day’s flow the same for both. Figure 16.3 plots each day’s slippage against its schedule part.

On the high-volume days the schedule part explains 99.1% of the variance of the static VWAP’s slippage and 98.6% of the dynamic one’s: the slippage’s standard deviation is 2.24 ticks for the static schedule and 1.75 for the dynamic one, the schedule part’s 2.17 and 1.71, while the execution part varies by only 0.21 and 0.20 around a mean of 0.66 and 0.73 ticks (the half-spread and impact every child pays). On the other days the slippage is smaller (standard deviations 0.48 and 0.41) and the schedule part explains less of it, 73.9% and 68.5%. The dynamic schedule’s lower dispersion on high-volume days is not a reliable gain on sixteen days: it did better on seven of them, the paired difference in squared slippage is 1.5 with a standard error of 1.8, and most of it comes from one news day (7.5 ticks for the static schedule, 5.4 for the dynamic). The panel’s 3 800 days, where the tracking error falls from 17.7 to 17.2 basis points, measure the same effect precisely: real, and small.

16.4 Participation and its feedback

A participation algorithm trades in each bin a share $r$ of the previous bin’s volume. The volume it sees includes its own prints, and that makes it chase itself: if it trades $q$ against the other traders’ $o$ in each bin, then $q=r(o+q)$, so it trades $q/o=r/(1-r)$ of the volume the market would have had without it, 25% at $r=20\%$. Two such algorithms buying the same stock each count the other: $q=r(o+2q)$, so each trades $r/(1-2r)$, 33%, and the total volume grows by $1/(1-2r)$. And if the other traders react to its buying (here the fundamentalists sell into the price it pushes up), their extra volume feeds the same loop.

    """Trade in bin k to be `rate` of the market: rate x bin k-1's whole volume, the algorithm's own included."""
    def schedule(k, total, own, planned):
        if k == 0:
            return 0.0
        return min(qty - planned, rate * total[k - 1])
    return schedule

Table 16.2 runs one and two such buyers of 15 000 shares at $r=20\%$, on a normal day and on a thin one with 40% of the normal activity, eight days each, against the same days without them.

The participation stays near its target; the pace does not. On the normal day the order lasts five minutes, too short for the loop to build (the last bin is also partial), and the pace is 21.1%; on the thin day it lasts almost twelve and reaches 24.9%, the $r/(1-r)$ of the argument. With a second buyer the pace rises to 24.6% and 29.4%, toward $r/(1-2r)$, and on the normal day the impact cost rises from 6.4 to 10.0 ticks: each algorithm pays for the other’s buying and trades faster because of it. The other traders’ reaction adds little volume here (0.12 shares per share bought or less, barely measurable). The thin day’s lower cost per share is this market’s doing: its fundamentalists pull the price back at a rate that does not thin with the day, and a slower order leaves them more time. A real thin day usually costs more; what carries over is that the algorithm’s clock is the volume, and on a thin day its own trades are a larger part of that clock.

16.5 Implementation-shortfall and close algorithms

The implementation-shortfall algorithm of Table 16.1 follows chapter 14’s trajectory with $\kappa T=4$: it front-loads, buying 87% of the order in the first half of the day. Its benchmark is the arrival price, so it is the only algorithm measured against the price the order actually met; its cost against arrival, 2.9 ticks, has the largest spread of the measured-against-benchmark numbers only because the others’ benchmarks move with the day. The target-close algorithm keeps 30% for the closing auction (a market-on-close order sent 30 seconds before the close) and trades the rest over the last nine bins in proportion to the profile. Its tight tracking of the close is bought with the largest impact cost (6.8 ticks), and its apparent gain against the close is the close it moved.

What the table does not show is the choice between them, which belongs to the portfolio manager: a VWAP benchmark suits an order whose urgency is low and whose trader wants to look like the day’s average; implementation shortfall suits an order with alpha that decays; the close suits funds valued at the close. Chapter 19 measures algorithms against each other with transaction-cost analysis, and chapter 28 builds one that trades each slice through the placement and routing of chapters 17 and 18.

16.6 Tutorial: volume forecasts and benchmark algorithms

16.7 Build: benchmark algorithms

16.8 Exercises

16.9 Problem: VWAP on a Day That Was Not Average

16.10 Interview questions