Table Of Contents

Recap
Fixing Bugs
Calculating Turnover
Updating the historical data in our lab
How To Use Turnover Next Issues

Recap

It's been a while since we had our last real article on Feb 23. There has also been an influx of new subscribers so if you're looking for a somewhat longer recap, you can find one in the last issue, where we crafted up our very first backtest. This issue will also be somewhat shorter than usual since I'm still working on getting back on schedule again.

Unfortunately, we're still not done with coding our backtest. Again, "If you use this implementation to make assumptions about real world performance, you're going to have a bad time!" Let's take things a step further, we have a lot on our list:

• calculating turnover,
• decreasing turnover via error threshold,
• more accurate trading fee calculation,
• scrape and incorporate funding,
• adding slippage & bid-ask spread,
• fixing some bugs,
• etc.

For some of these we need more data, for others we only need to change the current implementation. Let's do the implementation only ones first.

Fixing bugs

Before we start looking at details, it's worth talking about some little bugs we introduced in our last backtest. When copy pasting the 0.055% from Bybits fee structure into our calculation, we didn't adjust it properly:

COPY# WRONG:

[...]
# ByBit fees
# fee = 0.001 #spot
fee = 0.0055  # perp & futures


# CORRECT:
[...]
fee = 0.00055  # perp & futures

To make things easier, we can convert the percentage from Bybits fee structure to a decimal. This way we can just copy paste the percentage values and still calculate the fees paid correctly by multiplying our notional traded with the fees decimals.

COPY[...]
# ByBit fees
# fee = 0.1 #spot
fee = 0.055  # perp & futures

# convert percentage to decimal
fee = fee / 100

We also introduced another bug. When adjusting our raw forecast for volatility, we forgot to add .diff() to the instruments close prices. We want to calculate the instruments volatililty of returns, not its close prices:

COPY# WRONG
[...]
df['price_vol'] = df['close'].ewm(span=35, min_periods=10).std()
df['fc_vol_adj'] = df['raw_forecast'] / df['price_vol'].ffill()


# FIXED
[...]
df['instr_price_returns'] = df['close'].diff()
df['price_vol'] = df['instr_price_returns'].ewm(span=35, min_periods=10).std()
df['fc_vol_adj'] = df['raw_forecast'] / df['price_vol'].ffill()

These bugs have also been fixed in the GitHub Repo for Issue 16. Now that we got that out of the way, let's return to more interesting tasks.

Calculating Turnover

Simply put, your turnover measures how quickly you are trading. This is a useful metric to us because we can combine it with the costs of trading to generate a standardized measure for comparison across different trading speeds and instruments. In theory, the quicker we trade, the more we should pay for the increase in turnover. So if our "extra" returns - which based on a backtest alone aren't that reliable anyway - don't overcome the extra costs in trading quicker, we might end up generating fewer returns than we thought.

There are lots of different approaches when it comes to calculating turnover depending on your investment approach and horizon. We're just going to calculate our average position and compare it with the positions we're actually taking to get a sense of how often we flip or readjust our positions.

To find our average position, we can simply divide our daily cash risk by the risk of holding one instrument unit, just like we did when calculating how many units we need to own:

COPY# Calculating how many units needed
[...]
annual_cash_risk_target = trading_capital * annual_perc_risk_target
daily_cash_risk = annual_cash_risk_target / np.sqrt(trading_days_in_year)

for index, row in df.iterrows():
    notional_per_contract = (row['close'] * 1 * contract_unit)

    daily_usd_vol = notional_per_contract * row['instr_perc_returns_vol']
    df.at[index, 'daily_usd_vol'] = daily_usd_vol

    units_needed = daily_cash_risk / daily_usd_vol
    df.at[index, 'units_needed'] = units_needed
    [...]

# Calculating our average position
[...]
df['unit_value'] = df['close'] * contract_unit * 0.01
daily_unit_risk = df['unit_value'] * df['instr_perc_returns_vol'] * 100

avg_pos = daily_cash_risk / daily_unit_risk
print('avg position', avg_pos)
# avg position time_close
# 2010-07-14         NaN
# 2010-07-15         NaN
# 2010-07-16         NaN
# 2010-07-17         NaN
# 2010-07-18         NaN
#                 ...
# 2025-01-22    0.039214
# 2025-01-23    0.040231
# 2025-01-24    0.041014
# 2025-01-25    0.042200
# 2025-01-26    0.043148

Next we're going to compare our actual positions with the averages to see how frequently we need to adjust the amount of units we need to hold. For this we calculate the absolute difference between them. We're also going to normalize them by dividing the actual positions through the averages to ensure we're measuring changes relative to a typical size, which makes it easier to compare across different instruments. If we just used raw contract counts, changes could look massive or tiny depending on how large those absolute numbers are.

The absolute difference between those is our average daily turnover, which we can annualize by multiplying with trading days in a year:

COPY[...]
positions = df['pos_size_contracts']
actual_positions = positions.resample(resample_period).last()
avg_positions = avg_pos.reindex(actual_positions.index, method='ffill')

positions_normalised = actual_positions / avg_positions.ffill()
avg_daily_turnover = positions_normalised.diff().abs().mean()
print('avg_daily_turnover', avg_daily_turnover)
# avg_daily_turnover 0.09103789562490687

ann_turnover = avg_daily_turnover * trading_days_in_year
print('ann_turnover', ann_turnover)
# ann_turnover 33.228831903091006

Ok, so what does an annual turnover of ~33.23 a year mean? It means we're resetting a typical (average) sized position roughly 33 times a year using the EMAC(8,32) Crossover as our signal. We can set the fast_lookback of our EMAs to 2 for a quick check if the implementation works as expected:

COPY[...]
fast_lookback = 2
# fast_lookback = 8 # original
slow_lookback = fast_lookback * 4
[...]

print('avg_daily_turnover', avg_daily_turnover)
[...]
print('ann_turnover', ann_turnover)
# avg_daily_turnover 0.3851419142160126
# ann_turnover 140.5767986888446

That makes sense! If our signal reacts quicker, we expect to turn over our positions more. Let's add this metric into our backtest report:

COPY[...]
def plot(column_name1, column_name2):
    [...]
    ax4.plot(df['close'].index, df[column_name2], color='#de4d39', label=column_name2)
    ax4.set_title(column_name2)
    ax4.set_xlabel('Time')
    ax4.set_ylabel(column_name2)
    ax4.text(
        0.05, 0.95,
        (
            f"{'SR:':<15}{strat_sr.iloc[-1]:>21.2f}\n"
            f"{'Ann. std_dev(%):':<15}{(np.sqrt(trading_days_in_year) * strat_std_dev.iloc[-1]):>11.2f}\n"
            f"{'Ann. Turnover:':<15}{ann_turnover:>15.0f}"
        ),
        transform=ax4.transAxes,
        fontsize=20,
        verticalalignment='top',
        bbox=dict(facecolor='white', alpha=0.5)
    )
    [...]


plot('daily_perc_pnl', 'cumulative_usd_pnl')

This plot function looks more and more messy. We're passing some values but using others from global scope. I don't like it but right now I also don't mind. We want to keep moving by working on more important things like backtest metrics. At some point we'll refactor this into a nicely defined interface with a generalized header and signature.

The full, updated code can be found in this weeks GitHub Repo

How to use turnover

Turnover in itself isn't all that useful. It simply tells us how often we - literally - turn over our book to trade our signals based on desired exposure. To make it make more sense, we need to combine it with trading costs. However, this weeks article is done now. All of the abov might have been a lot to absorb for non-devs so we're going to give it a while to settle. Let me know if you like the articles more bite-sized like this or not.

Next issues

In the next issues we're going to tackle more things from our list. We're going to combine turnover and trading fees to caclulate our expected annual trading costs to see how much profit we're giving back for trading quicker or slower. We're also going to add other costs like funding fees to make our backtest more well-rounded.

So long, happy trading!