Recap
Risk Targeting
How To Find Your Risk Target
Example Kelly Risk-Targeting
Risk Of Holding One Contract
Scaling BTC Risk Down To Daily Risk Target
Calculating Positionsize Based On Forecast
Continuously Updating The Values

Recap

Last week we processed the raw forecast of a simple EMA Crossover (8-32) into a continuous forecast using normalization and rescaling techniques suggested by Rob Carver. Ultimately we want to rely on more than one simple rule for our forecast, so at some point we need to aggregate them the same way. For now we're going to keep things simple so we can keep moving through our current development cycle quickly.

We're almost ready to code and run our first - very simplistic - backtest. There's really only one part missing: simulating actual trading based on our forecast.

For this we need to implement taking positions, which comes with a bunch of concepts to address.

Risk Targeting

When we're talking about "taking on positions", we're talking about betting money on a directional trend move. Everytime, we're betting on something, we need to think about the risk involved so we can manage it properly. We don't want to end up losing all or most of our money due to "bad luck" before our chances of winning can be realized. Getting shut out of betting this way is your #1 worst enemy as a trader!

How do we control our risk?

A very simple way of minimzing risk of ruin is using a risk target. A risk target specifies how much you're willing to lose when running your strategy. When defining your risk target, there are a lot of factors to take into account, which include - but are not limited to - things like personal risk appetite, expected performance and behaviour of returns.

Are you comfortable with losing 60% of your portfolio during your trading year? Can you sleep like a baby if you know that this loss has a 30% chance of hitting each day?

These are all questions you need to think about when dialing in your risk target.

How To Find Your Risk Target

Lots of traders like to use something called Kelly-betting, where your expected performance in terms of Sharpe Ratio dictates the amount of risk we should put on.

While this assumption can be derived and makes sense theoretically, it has a few drawbacks we need to address.

First of all, you can't know your true Sharpe Ratio in advance! A backtested Sharpe Ratio is a good first approximation of what your live trading performance might look like, certainly better than not looking at any metric at all. But - and this is a big but - backtested performance is almost always going to have an inflated Sharpe Ratio.

It assumes a Gaussian normal distribution of returns, which is not really how financial instruments behave in the real world.

Even if we were to ignore this fact, it's unlikely that historical returns will look the exact same way in the future. The price curve printed was merely one draw out of a bunch of different random draws possible. Different skew profiles also hold different kinds of risk you need to prepare for.

The list goes on and on.. but luckily there is a nice and easy short-cut we can use: just divide your Kelly risk-target by half!

Let's look at an example.

Example Kelly Risk-Targeting

Since we don't have a working backtest yet, let's just assume we have a mid-longterm trend-following strategy with a Sharpe Ratio of 0.4, which is a somewhat realistic figure for what we're trying to build. This would translate to an annual risk target of 40% using Kelly-betting. If we divide that by half, we get 20%.

Okay, 20%, so far so good. But what does this mean? Remember how we deemed the annualized Standard Deviation as a proper risk measurement tool? The 20% mean we want to target an annual Standard Deviation of returns of 20% in our portfolio.

This also means that we're willing to lose 20% of our trading capital on average, which equates to $2,000. Since we are processing new information daily (EOD data), we can find our expected average daily loss by reversing the annualization of the risk target using the formula:

$\frac{ann\_risk\_target}{\sqrt{\text{ann\_trading\_days}}}$

$\frac{\$2,000}{\sqrt{\text{365}}} \text{= \$104.68}$

An annual risk target of 20% on a $10,000 account is the same as a daily risk target of $104.68. Are you really comfortable with this number? If not, you need to adjust your annual risk target to reflect your risk appetite.

Risk Of Holding One Contract

All of the above was done on the portfolio level of our trading system. We still need to figure out how to translate this into acionable information so we can take on positions reflecting our risk management approach.

The key question of this Issue is: "how much BTC do we need to buy/sell to effectively target a daily risk of $104,68?"

To find the answer to this question, we need to know how much we're risking when exposing ourselve to BTC. This can easily be done by measuring BTCs daily standard deviation:

import numpy as np
import pandas as pd

import psycopg2

from dotenv import load_dotenv
import os


load_dotenv()


conn = psycopg2.connect(
    dbname=os.environ.get("DB_DB"),
    user=os.environ.get("DB_USER"),
    password=os.environ.get("DB_PW"),
    host=os.environ.get("DB_HOST"),
    port=os.environ.get("DB_PORT")
)

symbolname = 'BTC'

cur = conn.cursor()
cur.execute(f"""
    SELECT ohlcv.time_close, ohlcv.close
    FROM ohlcv
    JOIN coins ON ohlcv.coin_id = coins.id
    WHERE coins.symbol = '{symbolname}'
    ORDER BY ohlcv.time_close ASC;
""")
rows = cur.fetchall()
cur.close()
conn.close()

price = rows[-1][-1]
date = rows[-1][0]
print(f'Current {symbolname} price as of {date}', price)

df = pd.DataFrame(rows, columns=['time_close', 'close'])
df['time_close'] = pd.to_datetime(df['time_close']).dt.strftime('%Y-%m-%d')
df.set_index('time_close', inplace=True)
df['perc_change'] = df['close'].pct_change()
df['perc_change_ewm_vol'] = df['perc_change'].ewm(adjust=True, span=35, min_periods=10).std()

daily_price_vol_perc = df['perc_change_ewm_vol'].iloc[-1] * 100
print(f'Daily price VOL %', daily_price_vol_perc, '\n')

# Current BTC price as of 2025-01-26 23:59:59 102682.4970331773
# Daily price VOL % 2.362786019578918

With current conditions, we would risk about 2.36% on a daily basis. Now you might ask yourself, 2.36% of what?

Good question!

This figure represents your daily risk for your notional exposure. Owning 1 BTC, you'd have a notional exposure of $BTCs current price!

Now since it's not possible to short spot BTC further than selling everything we own and, given our forecast, we definitely want to short, we need to shift our thinking to futures. A very basic writeup of futures specific concepts can be found here.

Just to quickly reiterate: they give us the possibility to short and use a metric called Contract Unit to calculate your notional exposure.

We're going to take Bybits Perpetual BTC/USDC Contract as an example. This makes things easy since its contract unit is exactly 1 BTC.

[...]
contract_unit = 1
units_bought = 1
notional_exp = units_bought * price * contract_unit
print(f'Notional exposure of {units_bought} unit {symbolname}', notional_exp)

# Notional exposure of 1 unit BTC 102682.4970331773

So what is 2.36% of 1 BTC? To answer this we can simply multiply our notional exposure of 1 BTC by its daily standard deviation.

daily_vol_risk = notional_exp * daily_price_vol_perc
print(f'PnL for {daily_price_vol_perc * 100}% move owning {units_bought} units {symbolname}', daily_vol_risk, '\n')

# PnL for 2.362786019578918% move owning 1 units BTC 2426.16768445445

Owning 1 Bybit contract for BTC/USDC would expose us to about $2,426.17 risk on a daily basis.

Scaling BTC Risk Down To Daily Risk Target

I think we can all agree that $2,425.17 is way more than our daily risk target of $104,68. Buying or selling 1 full contract is definitely not an option!

The next key question we want to answer is: If holding 1 BTC contract has a daily risk of $2,425.17 and we only want our daily PnL to fluctuate by $104,68, how many contracts do we need to hold?

This is easy to answer! We already have all the inputs for the formula:

$\text{units\_needed = }\frac{\text{daily\_risk\_target}}{\text{daily\_USD\_VOL}}$

$\text{units\_needed = }\frac{\text{\$104.68}}{\text{\$2425.17}}\text{ \~= 0.043}$

trading_capital = 10_000
print(f'Trading capital', trading_capital)
annual_perc_risk_target = 0.20
annual_cash_risk_target = trading_capital * annual_perc_risk_target
print(f'Annual cash risk target', annual_cash_risk_target)

trading_days_in_year = 365
daily_cash_risk = annual_cash_risk_target / np.sqrt(trading_days_in_year)
print(f'Daily cash risk target', daily_cash_risk, '\n')


units_needed_for_daily_risk = daily_cash_risk / daily_usd_risk
print(f'Units needed for daily risk', units_needed_for_daily_risk)

# Trading capital 10000
# Annual cash risk target 2000.0
# Daily cash risk target 104.68478451804275

# Units needed for daily risk 0.04314820660946288

To achieve an annual risk target of 20% on a $10,000 trading account, given current conditions, we'd need to own about 0.043 contracts.

This would severly limit us in our trading if we were trading in the Tradfi world where you can only trade at least a single contract. Things are different in the crypto world though. We are allowed to trade partials of contracts!

Note that the calculations in this issue all work for tradfi too. It's just that we wouldn't be able to trade this exact example if the minimum amount to trade possible is 1.0

Calculating Positionsize Based On Forecast

There's only one part missing now. We didn't incorporate our forecast yet! Remember, we constructed our forecast so we can risk more on stronger forecast and less on weak ones. The above figure of 0.043 can be viewed as your average forecast. Since the average absolute value of our forecast is scaled to 10, under current conditions, you'd need to trade 0.043 contracts on average. If your forecast read +10, you'd need to buy 0.043 contracts. If it was 5, you'd need to buy half of that.

To find the correct amount of contracts wee need to own based on current forecast, we just need to divide it by the forecasts average absolute value of 10.

Using the code from last weeks issue, we can find our latets forecast values:

[...]
df['scaled_forecast'] = df['fc_vol_adj'] * df['scaling_factor']
df['capped_forecast'] = df['scaled_forecast'].clip(lower=-20, upper=20)

print(df['capped_forecast'].tail(5))

#                    close  raw_forecast  fc_vol_adj  scaling_factor  capped_forecast
# time_close
# 2025-01-22  103653.069242   3609.127556    0.644672       19.824441        12.780269
# 2025-01-23  103960.171637   3659.404260    0.654407       19.812440        12.965391
# 2025-01-24  104819.484485   3785.732356    0.674000       19.809293        13.351458
# 2025-01-25  104714.645366   3810.102692    0.678545       19.806148        13.439369

[...]
forecast = 13.439369
pos = units_needed_for_daily_risk * forecast / 10
print(f'Position size', pos)

# Position size 0.05798846703128104

Continuously Updating The Values

Note that these calculations were merely an example of using latest readings of all the inputs. A lot of these need to be updated on a daily basis because they change!

Your account size changes due to PnL wins and losses, $BTCs volatility and therefore its inherent daily risk changes, our forecasts change, etc.

Next week we're going to apply these over the whole timescale of historical data to finally finish our first backtest.

The full code can be found in this weeks GitHub repo

So long, happy coding!

Translating Forecasts Into Position Sizes

Table Of Contents