Draft:Forming Bars

Forming bars is a set of techniques in quantitative finance that constructs price series ("bars") based on sampling from trading activity rather than at fixed points in calendar time. The basic idea is to generate a bar when a certain event threshold is reached, such as a specified number of trades, a fixed traded volume, or a fixed traded amount of money. These event-based bars aim to reduce the heteroscedasticity and serial correlation often observed in returns sampled at regular time intervals, and to produce data that are more suitable for statistical analysis and machine learning.

Motivation

Traditional financial time series sample prices at fixed time intervals (for example, one minute or one day). Because trading activity and information arrival are highly uneven over time, these "time bars" can oversample quiet periods and undersample active periods, leading to clusters of volatility and other undesirable statistical properties.

Event-based bars treat the sampling scheme as a process subordinated to trading activity. Instead of taking one observation every h seconds, the sampling clock is advanced only when a particular quantity of trading "information" has been exchanged, such as a number of trades, contracts, or dollars. López de Prado argues that such constructions deliver sequences of returns that are closer to homoscedastic, display weaker serial dependence, and have more consistent information content per observation than time bars.

Empirical illustrations on E-mini S&P 500 futures, for example, show that the exponentially weighted average number of tick bars per day can vary strongly over time, volume bars often move inversely with the price level, while dollar bars tend to exhibit relatively stable sampling frequencies.

Construction

Event-based bars are usually defined on transaction-level data indexed by trades $t=1,\dots ,N$. Let $p_{t}$ be the transaction price and $v_{t}$ the traded volume at time $t$. Bars are defined by a sequence of stopping times $\tau _{0}<\tau _{1}<\tau _{2}<\dots$ that mark the end of each bar $i$. Within bar $i$, the usual open–high–low–close (OHLC) values and cumulative volume are computed from the trades with indices $t=\tau _{i-1}+1,\dots ,\tau _{i}$.

For time bars the stopping times are equally spaced in calendar time, for example $\tau _{i}-\tau _{i-1}=\theta _{\mathrm {time} }$. For event-based bars, the stopping times are defined by thresholds on trading activity:

• For tick bars a bar closes after a fixed number $\theta _{\mathrm {T} }$ of trades,

$\tau _{i}=\tau _{i-1}+\theta _{\mathrm {T} },\qquad i=1,2,\dots$

• For volume bars a bar closes when cumulative volume since the previous bar reaches a threshold $\theta _{\mathrm {V} }$,

$\sum _{t=\tau _{i-1}+1}^{\tau _{i}}v_{t}\geq \theta _{\mathrm {V} }$

• For dollar bars a bar closes when cumulative traded monetary value exceeds a threshold $\theta _{\mathrm {D} }$. Writing $x_{t}=p_{t}v_{t}$ for the dollar value of trade $t$,

$\sum _{t=\tau _{i-1}+1}^{\tau _{i}}x_{t}\geq \theta _{\mathrm {D} }$

Imbalance-based bars generalize these constructions by using signed order flow. Let $b_{t}\in \{+1,-1\}$ be the trade direction (for example, using the tick rule) and define signed volume $q_{t}=b_{t}v_{t}$. The tick imbalance over bar $i$ is

$B_{i}=\sum _{t=\tau _{i-1}+1}^{\tau _{i}}b_{t}$

and the volume imbalance is

$Q_{i}=\sum _{t=\tau _{i-1}+1}^{\tau _{i}}q_{t}.$

In imbalance bar schemes the bar is closed when the absolute imbalance exceeds a time-varying threshold based on its historical expectation, for example

${\bigl |}B_{i}{\bigr |}\geq \theta _{I,i}=\alpha \,\mathbb {E} \!\left[{\bigl |}B_{i}{\bigr |}\right]$

for tick imbalance bars, with analogous conditions using $Q_{i}$ for volume imbalance bars. The parameter $\alpha >0$ controls how aggressively the sampling responds to order-flow imbalances.

Types of bars

Several bar types have been described in the literature. They differ in the event that triggers the formation of a new bar.

Tick bars

Tick bars sample the market every time a fixed number of transactions has occurred (for example, every 1,000 trades). Each bar summarizes all trades between two tick thresholds and records fields such as opening price, highest price, lowest price, closing price, and total volume. Compared with time bars, tick bars tend to be more closely aligned with order book activity, although the number of contracts or shares per bar can vary widely.

Volume bars

A volume bar is a bar where a new observation is created each time a fixed number of shares or contracts is traded. For example, one volume bar might be created for every 10,000 shares traded. Because each bar contains (approximately) the same total trading volume, volume bars can mitigate fluctuations in trading volume that affect time bars, and they establish a more direct link between price changes and traded quantity.

Dollar bars

Dollar bars (or value bars) are defined by a fixed currency value of traded volume, such as a nominal value of US$100,000 per bar. Because the threshold is expressed in currency units, the number of bars becomes less sensitive to changes in price levels or shares outstanding, and the sampling frequency of dollar bar sequences tends to be more stable over time.

Imbalance and run bars

In addition to standard tick, volume, and dollar bars, several imbalance-based and run-based bar types have been proposed. In these constructions, a bar is formed when a measure of imbalance in the directed order flow, based on trading direction (buy or sell) and size, deviates significantly from its expected value. Examples include tick imbalance bars, volume imbalance bars, and dollar imbalance bars, as well as run bars that react to sequences of trades on the same side of the market. These bars aim to allocate more observations to periods of greater order flow imbalance, which may be associated with informed trading or significant price fluctuations.

Illustrative example

A simple numerical example illustrates how event-based bars differ from time bars. Consider the ten trades in the following table, with uneven time spacing and varying trade sizes:

Trade	Time (hh:mm:ss)	Price	Volume
1	09:30:01	100.0	50
2	09:30:03	100.1	75
3	09:30:10	99.9	200
4	09:31:00	100.2	150
5	09:32:30	100.5	300
6	09:33:00	100.4	100
7	09:34:00	100.6	250
8	09:36:00	100.8	400
9	09:40:00	101.0	500
10	09:45:00	100.7	600

If prices were sampled in 5-minute time bars starting at 09:30, the first bar would cover 09:30–09:35 and contain trades 1–7, the second bar 09:35–09:40 (trade 8), and later bars would contain trades 9 and 10. The number of trades and the traded volume per time bar vary substantially.

By contrast, if 500 shares is chosen as the volume threshold, the same trades would form volume bars as follows:

Volume bar	Trades included	Total volume	Open	High	Low	Close
1	1–5	775	100.0	100.5	99.9	100.5
2	6–8	750	100.4	100.8	100.4	100.8
3	9	500	101.0	101.0	101.0	101.0
4	10	600	100.7	100.7	100.7	100.7

In this example the number of volume bars is determined purely by cumulative trading volume. Within each bar the traded volume is similar in magnitude, even though the durations and numbers of trades in each bar differ. In larger real-world datasets, plotting the number of bars per day for time bars and volume bars typically shows that event-based constructions concentrate more observations in active periods and fewer in quiet periods.

Illustrative pseudocode

The following pseudocode, written in Python syntax, shows one way to implement volume bars. It is intended to illustrate the underlying idea rather than prescribe a particular implementation:

def volume_bars(trades, threshold):
    """
    trades: iterable of (timestamp, price, volume)
    threshold: volume per bar, e.g. 10_000
    returns: list of OHLCV tuples
    """
    bars = []
    cum_vol = 0
    open_ = high = low = close = None

    for ts, price, vol in trades:
        if cum_vol == 0:
            # start a new bar
            open_ = high = low = price
        cum_vol += vol
        high = max(high, price)
        low = min(low, price)
        close = price

        if cum_vol >= threshold:
            bars.append((ts, open_, high, low, close, cum_vol))
            cum_vol = 0  # reset for the next bar

    return bars

Conceptually similar algorithms can be written for tick bars (using the number of trades instead of volume), dollar bars (using price × volume), and for imbalance-based bars where the stopping condition depends on signed order flow.

Applications

Event-based bars are widely discussed in quantitative finance and financial machine learning as a preprocessing step in building trading and risk management models. They can be used to construct features for algorithmic trading strategies, to feed supervised learning models for return prediction, or to define event times in backtesting frameworks.

Subsequent research has explored other resampling schemes and compared event-based sampling with classic time-based sampling in training trading strategies and predictive models, for example in cryptocurrency markets and other high-frequency data sets.

In the same context, López de Prado introduces the ETF trick, a technique for dealing with multi-product or futures series by constructing a synthetic price process that tracks the value of a one-unit investment in an underlying exchange-traded fund or replicating basket. This approach can be used to handle contract rolls, spread inversions, and other discontinuities in futures and spread data before sampling, so that bar formation and event-based sampling operate on a continuous synthetic value series rather than on individual contracts.

ETF trick pseudocode

The following Python-style pseudocode illustrates one way to implement the ETF trick for rolled futures data, by computing the gaps at each roll and subtracting them from the price fields to obtain a continuous synthetic series:

def getRolledSeries(pathIn, key):
    series = pd.read_hdf(pathIn, key='bars/ES_10k')
    series['Time'] = pd.to_datetime(series['Time'],
                                    format='%Y%m%d%H%M%S%f')
    series = series.set_index('Time')
    gaps = rollGaps(series)
    for fld in ['Close', 'VWAP']:
        series[fld] -= gaps
    return series
# -----------------------------------------------------------------
def rollGaps(series, dictio={'Instrument': 'FUT_CUR_GEN_TICKER',
                             'Open': 'PX_OPEN',
                             'Close': 'PX_LAST'},
             matchEnd=True):
    # Compute gaps at each roll, between previous close and next open
    rollDates = series[dictio['Instrument']].drop_duplicates(
        keep='first'
    ).index
    gaps = series[dictio['Close']] * 0
    iloc = list(series.index)
    iloc = [iloc.index(i) - 1 for i in rollDates]  # index of days prior to roll
    gaps.loc[rollDates[1:]] = (
        series[dictio['Open']].loc[rollDates[1:]]
        - series[dictio['Close']].iloc[iloc[1:]].values
    )
    gaps = gaps.cumsum()
    if matchEnd:
        gaps -= gaps.iloc[-1]  # roll backward
    return gaps

The first function reads a futures time series (for example, E-mini S&P 500 contracts) and subtracts the cumulative roll gaps from fields such as the closing price and volume-weighted average price (VWAP). The second function computes the cumulative gaps at each roll date from the difference between the next contract’s opening price and the previous contract’s closing price.

See also

• Algorithmic trading
• High-frequency trading
• Candlestick chart
• Price action trading

References

This page will be placed in the following categories if it is moved to the article namespace.

Categories:

• Financial data analysis