# Backtesting.py - A complete guide

Backtesting.py is a lightweight backtesting framework in python. It very much takes its syntax from Backtrader. So if you're familiar with Backtrader at all you'll find Backtesting.py very natural and easy to pickup.

## Why use Backtesting.py?

Backtesting.py is great when you just want something that works. It's easy to install, has excellent documentation, and doesn't suffer from the bloat of other backtesting libraries with 10,000 different live-trading integrations.

As I mentioned, the syntax will be very familiar to those of you who have used Backtrader. I see it as a spiritual successor to Backtrader, and much more lightweight. It is event-driven, so you program the logic that is run on each bar successively much like you were actually trading the strategy day-to-day.

You can also bring your own indicator libraries, as it doesn't come pre-loaded with any. So feel free to use something lightening fast like TA-lib or something friendly like pandas-ta.

You don't need any data to follow along with this tutorial, as `backtesting.py`

comes pre-loaded with some `GOOG`

daily data that we can use.

## The simplest backtest

Here's the code for the simplest possible backtest you can do in backtesting.py.

```
1import datetime
2import pandas_ta as ta
3import pandas as pd
4
5from backtesting import Backtest
6from backtesting import Strategy
7from backtesting.lib import crossover
8from backtesting.test import GOOG
9
10class RsiOscillator(Strategy):
11
12 upper_bound = 70
13 lower_bound = 30
14 rsi_window = 14
15
16 # Do as much initial computation as possible
17 def init(self):
18 self.rsi = self.I(ta.rsi, pd.Series(self.data.Close), self.rsi_window)
19
20 # Step through bars one by one
21 # Note that multiple buys are a thing here
22 def next(self):
23 if crossover(self.rsi, self.upper_bound):
24 self.position.close()
25 elif crossover(self.lower_bound, self.rsi):
26 self.buy()
27
28bt = Backtest(GOOG, RsiOscillator, cash=10_000, commission=.002)
29stats = bt.run()
30bt.plot()
```

Make sure you `pip install`

the relevant libraries. I'm using `pandas-ta`

here because it's a little easier to install than `ta-lib`

but the principle is the same.

To get anywhere in `Backtesting.py`

, you need to create a `Strategy`

. You do that by creating a class that inherits from `backtesting.Strategy`

.

There are two main functions you need to worry about inside your strategy. The first is `init`

:

```
1...
2 # Do as much initial computation as possible
3 def init(self):
4 self.rsi = self.I(ta.rsi, pd.Series(self.data.Close), self.rsi_window)
```

This function is called as soon as the object is created and is only run once. You should put in here anything that can be pre-calculated ahead of time before your backtest, such as any technical indicators.

The I function is well worth a look at as it's what allows you to build indicators within the backtesting.py ecosystem. Then there's the `next`

function:

```
1def next(self):
2 if crossover(self.rsi, self.upper_bound):
3 self.position.close()
4 elif crossover(self.lower_bound, self.rsi):
5 self.buy()
```

`next`

is called on every candle as the backtest progresses. Essentially ask yourself, if you were there at the time of the candle, what would your logic look like. In our case we check if the rsi is above our `upper_bound`

. If it is close any positions we have (long or short). Otherwise check if it's below `lower_bound`

, in which case we should buy as much as we can of the asset. Note that `backtesting.py`

only buys whole numbers of shares.

Finally we run the backtest:

```
1bt = Backtest(GOOG, RsiOscillator, cash=10_000, commission=.002)
2stats = bt.run()
3bt.plot()
```

Which should open up a nice backtesting dashboard in your browser.

You can also print out `stats`

to get a nice overview of your strategy and common metrics:

```
1Start 2004-08-19 00:00:00
2End 2013-03-01 00:00:00
3Duration 3116 days 00:00:00
4Exposure Time [%] 29.329609
5Equity Final [$] 15411.94704
6Equity Peak [$] 15570.14704
7Return [%] 54.11947
8Buy & Hold Return [%] 703.458242
9Return (Ann.) [%] 5.205671
10Volatility (Ann.) [%] 23.556885
11Sharpe Ratio 0.220983
12Sortino Ratio 0.369511
13Calmar Ratio 0.1055
14Max. Drawdown [%] -49.342925
15Avg. Drawdown [%] -6.457642
16Max. Drawdown Duration 1609 days 00:00:00
17Avg. Drawdown Duration 99 days 00:00:00
18# Trades 9
19Win Rate [%] 77.777778
20Best Trade [%] 21.155672
21Worst Trade [%] -20.607876
22Avg. Trade [%] 5.015784
23Max. Trade Duration 202 days 00:00:00
24Avg. Trade Duration 101 days 00:00:00
25Profit Factor 3.418112
26Expectancy [%] 5.723001
27SQN 1.171459
```

## Parameter optimization

One really powerful feature of `Backtesting.py`

is the ability to optimize the parameters used in your strategy. You can select a range of values for any of the class variables defined in your strategy and it will grid-search to find the best portfolio for whatever metric you've defined.

To get this running for yourself, simply replace `stats=bt.run()`

with:

```
1stats = bt.optimize(
2 upper_bound = range(50,85,5),
3 lower_bound = range(15,45,5),
4 rsi_window = range(10,30,2),
5 maximize='Equity Final [$]')
```

For `maximize`

you can set any statistic that appears in the `stats`

dataframe, like the Sharpe ratio, the win rate, etc. Note that the optimizer always assumes higher is better, so if you put volitility as the parameter to optimize it will find the most volitile portfolio.

The stats you get in return will be the stats of the best performing set of parameters. You can find the exact parameters used either in the url of the web page that opens up, or else by indexing into `stats`

and accessing the class variables

```
1>> strategy = stats["_strategy"]
2>> strategy.upper_bound
375
4>> strategy.lower_bound
520
```

## Custom Optimization Functions

If one of the default metrics doesn't quite capture the metric you'd like to optimize for, you can create your own function.

```
1def optim_func(series):
2 if series['# Trades'] < 10:
3 return -1
4 else:
5 return series['Equity Final [$]']/series['Exposure Time [%]']
```

This function ingests the stats dataframe and returns a number. We want to remove all backtests that have less than 10 trades, so we return -1 for those backtests. Otherwise our metric is the total amount of equity divided by the amount of time we're in the market. Basically trying to make the most money in the least amount of time.

After you've defined your metric funtion you'll want to integrate it into the backtester:

```
1stats = bt.optimize(
2 upper_bound = range(50,85,5),
3 lower_bound = range(15,45,5),
4 rsi_window = range(10,30,2),
5 maximize=optim_func)
```

You'll have to play around with this to get something that you like that's not massively over-fit. But it allows you to optimize for things like lower volitility, etc.

## Parameter Heatmaps

As a way of visualizing which parameter combinations perform best it can be nice to draw a heatmap comparing two variables and how changing them changes the metric you're optimizing for. You'll want to replace the code below your strategy definition with:

```
1import matplotlib.pyplot as plt
2import seaborn as sns
3...
4class RsiOscillator(Strategy):
5 ...
6...
7
8bt = Backtest(GOOG, RsiOscillator, cash=10_000, commission=.002)
9
10stats, heatmap = bt.optimize(
11 upper_bound = range(50,85,5),
12 lower_bound = range(15,45,5),
13 rsi_window = range(10,30,2),
14 maximize='Equity Final [$]',
15 return_heatmap=True)
16
17# choose your colormaps from here
18# https://matplotlib.org/stable/tutorials/colors/colormaps.html
19hm = heatmap.groupby(["upper_bound","lower_bound"]).mean().unstack()
20sns.heatmap(hm, cmap="plasma")
21plt.show()
```

Since a heatmap can only display variations of two variables, we need to use a pandas `group_by`

to select the two variables we want to compare against eachother. Then apply an aggregation to simplify each group down to a single value. Finally we unstack the whole thing into a matrix that we can easily plot with seaborn.

There's a whole host of color pallets available at the link in the code block above.

## Multi-timeframe Strategies

For those of you fond of TA, we often want to examine a strategy on multiple timeframes. Say on the weekly and the daily. Thankfully there's a nice utility function called `resample_apply`

. It leverages Pandas to down-sample the data, apply our indicator, then up-sample it and forward fill the missing values. Here's a re-written version of our `init`

function that gives us the weekly rsi:

```
1# All initial calculations
2 def init(self):
3 self.daily_rsi = self.I(ta.rsiI, pd.Series(self.data.Close), self.rsi_window)
4
5 # This magical function does all the resampling
6 self.weekly_rsi = resample_apply(
7 'W-FRI', ta.rsi, pd.Series(self.data.Close), self.rsi_window)
```

All you have to do is feed in a pandas compatible timeframe, the function you want to apply, the data and any extra keywords that need to be passed into the function. At this point we can re-write our `next`

function to make use of our `weekly_rsi`

.

```
1def next(self):
2
3 if (crossover(self.daily_rsi, self.upper_bound) and
4 self.weekly_rsi[-1] > self.upper_bound):
5 self.position.close()
6
7 elif (crossover(self.lower_bound, self.daily_rsi) and
8 self.lower_bound > self.weekly_rsi[-1]):
9 self.buy()
```

Now we only trade if there's a crossover on the daily candles, and the weekly rsi is also above our threshold.

## Take Profit and Stop Loss

You can add a stop loss or take profit level in both your long and short trades as follows

```
1def next(self):
2
3 price = self.data.Close[-1]
4
5 if crossover(self.rsi, self.upper_bound):
6 self.position.close()
7
8 elif crossover(self.lower_bound, self.rsi):
9 self.buy(tp=1.15*price, sl=0.95*price)
```

Here we set a take profit at 15% and a stop loss at 5%. Note that due to how backtesting.py works, the final profit from your trade might be slightly higher/lower than the level you'd expect. This is because it only executes trades on the next bar, so if the price moves significantly overnight, that will affect your backtest. If you need very granular stop-losses and take-profits I'd recommend using more granular intra-day data.

## Extracting Trade Data

You can extract the series of trades made by the backtester for further analysis.

```
1print(stats['_trades'].to_string())
```

```
1 Size EntryBar ExitBar EntryPrice ExitPrice PnL ReturnPct EntryTime ExitTime Duration
20 27 373 422 362.67390 439.40 2071.60470 0.211557 2006-02-10 2006-04-24 73 days
31 33 493 525 365.70996 415.46 1641.75132 0.136037 2006-08-03 2006-09-19 47 days
42 24 862 925 561.83142 557.94 -93.39408 -0.006926 2008-01-23 2008-04-23 91 days
53 29 987 1126 467.65344 371.28 -2794.82976 -0.206079 2008-07-22 2009-02-09 202 days
64 19 1367 1424 547.68318 563.00 291.01958 0.027967 2010-01-25 2010-04-16 81 days
75 22 1437 1534 501.98196 512.86 239.31688 0.021670 2010-05-05 2010-09-22 140 days
86 19 1653 1740 573.94560 592.49 352.34360 0.032310 2011-03-14 2011-07-18 126 days
97 20 1873 1913 573.12396 646.60 1469.52080 0.128203 2012-01-26 2012-03-23 57 days
108 20 2072 2129 655.95930 767.69 2234.61400 0.170332 2012-11-09 2013-02-04 87 days
```

## Video tutorial

If you'd prefer a video tutorial, you can check out this video on my channel: