Recap
Equity Curves
No Code Version
EQ Curve As Performance Metric
Comparing Strategies Via Returns
Mixing In Risk (stdDev)
Revisiting Sharpe Ratio
Easy Comparison Across Instruments
Drawdowns
Why Not Use Drawdons As A Measure Of Risk
Why Drawdowns Can Actually Be A Good Thing

Recap

Last week we talked about the importance of a checklist to stay consistent in your approach to backtesting no matter what and gave you access to ours here which is modeled after our 4 F's of Backtesting Framework.

We also had a first look at The first F - Fetching historical price data. Before diving deeper into the remaining pillars of the framework, we're going to extend our backtest report a little.

Equity Curves

An equity curve is a graphical representation of the change in value of a strategy or instrument over time. It typically plots the profit or loss on the vertical axis against time on the horizontal axis. Equity curves are widely used by traders and investors to evaluate the performance of a trading strategy or investment. We're going to talk about if that's a good idea or not later on.

Let's start by plotting one for our BTCUSD long only spot strategy. Plotting the equity curve for our strategy is pretty straightforward, we tucked it away in the plots.py file in this weeks GitHub repo:

from metrics import calculate_cumulative_returns

def plot_equity_curve(returns, tickername):
    cumulative_returns = calculate_cumulative_returns(returns)

    plt.figure(facecolor='#f7e9e1')
    time_indices = range(len(cumulative_returns))
    plt.plot(time_indices, cumulative_returns, color='#de4d39', linewidth=2)

    plt.xlabel('Time')
    plt.ylabel('Cumulative Returns')
    plt.title('Equity Curve Over Time')
    plt.grid(True, which='both', linestyle='--',
             linewidth=0.5, color='#100d16')
    plt.tick_params(colors='#100d16')

    plt.savefig(f'equity_curve_{tickername}.png')

and the corresponding metrics.py function to calculate the cumulative return series:

def calculate_cumulative_returns(returns):
    return returns.cumsum()

This is a different formula than for calculating compounded returns!

Since we're never reinvesting or adding to our position but only hold 1 spot unit of BTC forever, it makes no sense to use the formula for compounding returns. This might not resemble a real world problem but it is what we're working with right now.

We already computed the daily percentage returns earlier to be able to calculate all the other performance metrics we're using, we can just pass them through to our new function:

from plots import plot_equity_curve
[...]
daily_returns = df['price'].pct_change().dropna()
[...]
plot_equity_curve(daily_returns, ticker)

You might recognize the shape of this curve. It's basically the BTC/USD price curve over time. Which makes total sense because we're just buying and holding 1 spot unit of BTC.

No Code Version

As always we've prepared a gDrive Sheet for you in case you want to follow along without coding or running our python scripts yourself. You can grab a copy of it here.

EQ Curve As Performance Metric

While an equity curve is a usefool tool to visualize a strategies change of value over time, it is a horrible (primary) performance metric because it only focuses on returns!

Now, you might be thinking to yourself 'wait a minute.. higher returns = more money. Shouldn't I always optimize for more money?!' and you're right, but..

As we've learned in Part I and Part II of this series, returns are only one side of the equation and for them to make sense they have to be put into context of the risk involved to get them.

There's no such thing as higher returns without higher risk!

Comparing Strategies Via Returns

Let's have a look at an example. To rid ourselves from any kind of bias like favorite instrument to trade etc. we're going to use synthetic price data generated with the python library numpy for two different strategies:

strategy1 with yearly returns of 7% and volatility (std_dev) of 12%
strategy2 with yearly returns of 12% and volatility (std_dev) of 24%

import numpy as np
# Set random seed for reproducibility
np.random.seed(42)


# Function to generate synthetic returns
def generate_returns(mu, sigma, periods):
    return np.random.normal(mu, sigma, periods)


# Parameters for two strategies
periods = 1500
annual_return_strategy1 = 0.07  # 7% annual return
annual_return_strategy2 = 0.12  # 12% annual return
annual_volatility_strategy1 = 0.12  # 12% annual volatility
annual_volatility_strategy2 = 0.24  # 24% annual volatility

trading_days_in_a_year = 252

# Calculate daily returns from annual returns
strategy1_mu = (1 + annual_return_strategy1) ** (1 / trading_days_in_a_year) - 1
strategy2_mu = (1 + annual_return_strategy2) ** (1 / trading_days_in_a_year) - 1

# Calculate daily volatilities from annual volatilities
strategy1_sigma = annual_volatility_strategy1 / np.sqrt(trading_days_in_a_year)
strategy2_sigma = annual_volatility_strategy2 / np.sqrt(trading_days_in_a_year)

# Generate returns
returns1 = generate_returns(strategy1_mu, strategy1_sigma, periods)
returns2 = generate_returns(strategy2_mu, strategy2_sigma, periods)

Using our our metrics.py file from this weeks GitHub Repository we can calculate their return_series and plot them as equity curves:

from metrics import calculate_cumulative_returns
import matplotlib.pyplot as plt

cumulative_returns1 = calculate_cumulative_returns(returns1)
cumulative_returns2 = calculate_cumulative_returns(returns2)

plt.figure(figsize=(14, 7), facecolor='#f7e9e1')
plt.plot(cumulative_returns1, label='Strategy 1 - Lower Risk', color='#de4d39')
plt.plot(cumulative_returns2, label='Strategy 2 - Higher Risk', color='#d3d3d3')
plt.title('Equity Curves of Two Synthetic Strategies')
plt.xlabel('Time')
plt.ylabel('Equity Value')
plt.legend()

plt.tight_layout()
plt.savefig('eq_curves_synth.png')

Again, looking at the equity curves alone, we'd clearly be better of putting our money into strategy 2. At any given point in time its returns are outperforming strategy 1. After all, we've hardcoded strategy 2 to return 5% more.

Mixing In Risk (stdDev)

Now suppose we have $10.000 to invest. How much money do we make putting it in each strategy?

$\text{Returns(s1):} \quad \$10,000 \times 0.07 = \$700$
$\text{Returns(s1):} \quad \$10,000 \times 0.12 = \$1.200$

We're still earning more money using strategy2 so what's with all the fuzz?

It's true that we're earning more money with strategy 2 - which makes sense given the higher returns - but we're also taking on more risk! If that is intended is another type of question but let's focus on the numers right now:

$\text{Risk(s1):} \quad \$10,000 \times 0.12 = \$1.200$
$\text{Risk(s2):} \quad \$10,000 \times 0.24 = \$2.400$

Using strategy 2 we're risking twice as much!

So the comparison of their returns so far was nonsense! Of course we're going to earn more if we risk more. To make it a fair comparison we need to adjust our betsize in strategy 1 to target the same risk as with strategy 2:

$\frac{\$2,400}{\$1,200} = 2$

We need to multiply our betsize by 2:

$\text{Risk(ss1):} \quad \$10,000 \times 2 \times 0.12 = \$2.400$
$\text{Risk(ss1):} \quad \$10,000 \times 0.24 = \$2.400$

Let's have a look at our returns again:

$\text{Returns(ss1):} \quad \$10,000 \times 2 \times 0.07 = \$1.400$
$\text{Returns(ss2):} \quad \$10,000 \times 0.12 = \$1.200$

When targeting the same risk we're all of a sudden earning more using strategy 1!

Revisiting Sharpe Ratio

It looks like strategy 1 is more efficiently earning rewards per risk taken. If only there was some kind of indicator we could consult to quickly estimate the efficiency of a strategies risk:reward behaviour.

Remember the formula for calculating the Sharpe Ratio?

It is calculated by using the formula $\text{SR} = \frac{[R_p - R_f]}{\sigma_p}$ where:

$R_p$ : Expected portfolio return

$R_f$ : Risk-free rate of return

$\sigma_p$ : Standard deviation of the portfolio return.

That's right, the formula is adjusting a strategies returns based on its risk using the std_dev like we just manually did . Let's calculate the Sharpe Ratio for both our strategies using our metrics.py file and plot it alongside the equity curves:

from metrics import calculate_sharpe_ratio, annualise_sharpe_ratio
[...]
sharpe1 = annualise_sharpe_ratio(calculate_sharpe_ratio(returns1))
sharpe2 = annualise_sharpe_ratio(calculate_sharpe_ratio(returns2))


plt.figure(figsize=(14, 7), facecolor='#f7e9e1')

plt.subplot(1, 2, 1)
plt.plot(cumulative_returns1, label='Strategy 1 - Lower Risk', color='#de4d39')
plt.plot(cumulative_returns2, label='Strategy 2 - Higher Risk', color='#d3d3d3')
plt.title('Equity Curves of Two Synthetic Strategies')
plt.xlabel('Time')
plt.ylabel('Equity Value')
plt.legend()


plt.tight_layout()
# plt.savefig('eq_curves_synth.png')

plt.subplot(1, 2, 2)
strategies = ['Strategy 1', 'Strategy 2']
sharpe_ratios = [sharpe1, sharpe2]
plt.bar(strategies, sharpe_ratios, color=['#de4d39', '#d3d3d3'])
plt.title('Sharpe Ratios')
plt.ylabel('Sharpe Ratio')

plt.tight_layout()
plt.savefig('eq_vs_sr.png')

Sharpe Ratio of Strategy 1: 1.37
Sharpe Ratio of Strategy 2: 0.73

A higher Sharpe Ratio basically means that we're more efficiently farming returns out of our risk.Strategy 1 risk:reward ratio is clearly better than strategy 2. If you're not convinced yet just ask yourself the quqestion

'would you rather bet $2.400 to win $1.200 or bet $2.400 to win $1.400?'

Returns of Strategy 1: $700.00
Risk of Strategy 1: $1,200.00

Returns of Strategy 2: $1,200.00
Risk of Strategy 2: $2,400.00

Scale Factor: 2.0

Scaled Returns of Strategy 1: $1,400.00
Risk of Scaled Strategy 1: $2,400.00

Returns of Strategy 2: $1,200.00
Risk of Strategy 2: $2,400.00

Easy Comparison Across Instruments

As you can see, using returns or compounded returns (GACR) or anything else that does not adjust for risk to compare across different strategies or instruments is prone to misguide you.

Since the Sharpe Ratio always adjusts the strategies or instruments returns for its own volatility, it automatically normalizes across them so comparison can be done on a simple one-to-one basis instead of having to dissect and adjust in further steps via guesswork after calculating the gains.

Drawdowns

Inside of an equity curve lives another type of curve: the Drawdown Curve. It is a graphical representation of the declines in value from the peak equity of your portfolio (or whatever benchmark you're using).

Let's circle back to our BTC long only strategy to understand what a drawdown is. You can calculate and plot it with the following code:

def calculate_drawdown(returns):
    cumulative_returns = calculate_cumulative_returns(returns)
    cumulative_max = cumulative_returns.cummax()

    drawdown_series = cumulative_max - cumulative_returns
    drawdown_series = drawdown_series / (1 + cumulative_max)
    return drawdown_series

def plot_drawdown(returns, tickername):
    drawdown_series = calculate_drawdown(returns) * -1

    plt.figure(facecolor='#f7e9e1')
    time_indices = range(len(drawdown_series))
    plt.fill_between(time_indices, drawdown_series, color='#de4d39', alpha=0.5)

    plt.xlabel('Time')
    plt.ylabel('Drawdown')
    plt.title('Drawdown Over Time')
    plt.grid(True, which='both', linestyle='--',
             linewidth=0.5, color='#100d16')
    plt.tick_params(colors='#100d16')

    plt.savefig(f'drawdown_{tickername}.png')

[...]
daily_returns = df['price'].pct_change().dropna()
[...]
drawdowns = calculate_drawdown(daily_returns)
[...]
plot_drawdown(daily_returns, ticker)

We're using only our initial investment as benchmark for the drawdown here so naturally the drawdowns are getting smaller and smaller over time.

Why Not Use Drawdowns As A Measure Of Risk

You're probably wondering why we're not addressing metrics like Max Drawdown, Max Drawdown Duration, Recovery Time, Calmar Ratio, Ulcer Index, etc.

We don't like to use raw drawdowns as a performance metric because it again focuses only on one side of the equation - this time the risk. In addition There is only one max drawdown in our dataset so you're basically depending on a very small subset of your data to evaluate your strategies risk. Statistically speaking it's just the loudest noise.

Furthermore things like Max Drawdown only give you the worst case scenario without taking into consideration the likelihood and magnitude of different levels of losses or gains, which in fact might even give false hope. Don't dare to think that the historical max drawdown is also the worst that could happen in the future!

The Standard Deviation on the other hand captures both - the up and downside volatility by measuring movements away from the mean instead of only the losses. It acts as a probabilistic view of future performance because it quantifies the distribution of returns and losses equipping you with the power to calculate confidence intervals for how often and by how much returns might deviate (68-95-99.5 rule). Its normalizing properties make it easier to compare performance across instruments.

Why Drawdowns can actually be a good thing

Everybody thinks of drawdowns like an enemy without realising that they are just a random outcome of your overall distribution. Volatility goes both ways! If it goes your way, it's returns, if it goes against you, it's a drawdown.

The volatility could have gone either way! You just happened to be on the wrong side of it this time so you've experienced a drawdown.

When you try to filter out drawdowns, you're also filtering out opportunities for the same amount of returns!

You can't go without drawdowns. There will be one out there for you eventually.

Risk Management For Trading - Part III - Equity & Drawdown Curves

Table of Contents