Skip to content
/ getting-started Public

Start developing and backtesting your own automated trading strategies

tradingstrategy.ai
57 stars 9 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

tradingstrategy-ai/getting-started

BranchesTags

Repository files navigation

Getting started with algorithmic trading with TradingStrategy.ai

splash

Support and social media

Got any questions? Pop into our Discord.

Prerequisites

In order to get started you need

  • Github user account
  • Basic Python and data science knowledge
    • Python scripting
    • Pandas
    • Jupyter Notebook
  • Basic algorithmic trading knowledge
    • Understanding price chart and price action
    • Technical indicators

If you use Github Codespaces, no additional software is needed, you can do the first tests in your web browser.

To get a quick primer on the Trading Strategy framework, check the Trading Strategy workshop video recording.

Development environment options

You can either run and edit these examples

Example strategy backtests

Here are example notebooks for backtesting. Each of the backtest code can be taken to a live trading strategy as is. The examples vary between from old fashioned technical indicator based algorithms to portfolio construction and DeFi yield optimisation.

Individual backtests:

Example grid and optimisation searches

Grid searches run several backtests over multiple strategy parameter combinations. This allows you to "brute force search" better strategies and explore the behavior of a strategy with different parameters.

  • Multipair 1h: grid search

    • Same as Multipair 1h: An ATR-based multipair breakout strategy using Binance CEX data above
    • We have converted Parameters to individual parameter values to searchable option lists
    • Grid search over parameters and see if it improves the performance

  • Bollinger Bands BTC 1h: Gaussian Process optimiser

    • This notebook users Gaussian Process (GP) instead of grid search to find the best strategy parameters
    • Gaussian Process is much faster than brute forcing exhaustive grid search
    • This is using scikit-optimise library
    • Setting up optimiser is somewhat more complicate than setting up a grid search

  • Multipair ATR breakout: custom optimisation target

    • This notebook is using an optimiser with a custom optimisation search function
    • We weight 75% on Sharpe, 25% on Maximum Drawdow

Example research only notebooks

  • Uniswap CSV export of top 100 pairs
    • This Python script downloads 1d trading data for all DEX pairs
    • From this dataset we export OHCLV CSV for top 100 most liquid pairs on Uniswap v2 and v3 on Ethereum
    • This CSV can be then imported to the various trading strategy development applications like RealTest and MetaTrader
  • Uniswap CSV export of top pairs, survivorship-bias free and scam filtered
    • This is more advanced version of the script above
    • This Python script downloads 1d trading data for all DEX pairs
    • From this dataset we export OHCLV CSV for top 100 most historically liquid pairs, instead of today's liquid pairs
    • We will also do a risk scoring check using TokenSniffer to avoid honeypots and scams
  • Uniswap CSV export of top pairs, aggregated liquidity and volume
    • This is more advanced version of the script above
    • This version aggregates volume and liquidity across the same trading pairs
    • E.g. if the same pair trades on Uniswap v2 and Uniswap v3 different pools with fee tiers, volume and liquidity are aggregated
  • ADX regime filter research
    • This is an indicator visualisation -only notebook for testing different ADX market regime filter values
    • The notebook will render the regime detection (bull market, bear market, crab market) of various cryptocurrencies
    • The notebook shows how indicators can use data from other indicators using indicator dependency resolution
    • Medium complexity
  • Regime filter Bayes and Gaussian Proces (GP) optimiser
    • The same as above
    • Finds optimal market regime filter parameters for a certain definition of optimal
    • Uses scikit-optimize Python package to find optimal values for a regime filter
    • Demostrates how to integrate scikit-optimizer pipeline into the notebooks
    • Uses Gaussian Process (GP) instead of a grid search, being much faster, demostrating the benefits of an optimizer
    • Advanced complexity

Example live trading

  • Live trade executor example repo
    • Set up a Docker instance that runs a strategy for live trading

How to run on Github Codespaces

In this tutorial, we open a single backtest in Github Codespaces and run it. You can do all in your web browser using your Github account, no software is needed.

Press Create codespace master on Github repository page (master refers to the primary development branch of Git version control system).

This will give you a page showing your codespace is being launched.

After a while your Github Codespaces cloud environment is set up. The first launch is going to take a minute or two.

In the file explorer on the left, open a notebook: notebooks/single-backtest/matic-breakout.ipynb.

After opening the notebook click Clear all Outputs and then Run all button Jupyter toolbar.

When you are asked to Select kernel. Choose Python Environments.. and then /usr/local/bin/python.

img.png

You should see now notebook running, indicated by the progress indicator and run time count down in each notebook cell.

img.png

After the notebook is running successfully, you should be able to press Go to on the toolbar and see the backtesting progress bar going on. You will see a separate progress bar for 1) downloading data (done only once) 2) calculating technical indicators 3) running the backtest.

img.png

Note: If you see a text "Error rendering output item using 'jupyter-ipywidget-renderer. this is undefined. it means Visual Studio Code/Github Codespaces has encountered an internal bug. In this case press Interrupt on a toolbar, close the notebook, open it again and press Run all again. It happens only on the first run.

Shortly after this backtests results are available.

You can find them by scrolling down to the different sections

  • Equity curve
  • Performance metrics
  • otehrs

img.png

And now you are done with our first backtest! Continue below to learn more how you can get started with your own strategies.

Setting up Python environment from command line

Example how to run notebooks and scripts from the command line.

# Get all Python source code we need
# (A lot of code)
git clone --recursive https://github.com/tradingstrategy-ai/trade-executor.git deps/trade-executor

# Create virtual environment
poetry install

# Active Pytohn virtual environment
poetry shell

# Run script
python scripts/prefilter-uniswap-v3-ethereum.py

Strategy backtest notebook structure

Each strategy backtest notebook will consist of following phases.

  • Set up: Create Trading Strategy client that will download and cache any data
  • Parameters: Define parameters for your strategy in Parameters Python class
  • Trading pairs and market data: Define trading pairs your strategy will use and method to construct a trading universe using create_trading_universe() Python function. This function will take your trading pairs and additional information (candle time frame, stop loss, needed lending rates) and construct Python dataset suitable for backtesting. See documentation.
  • Indicators: In this phase, you have create_indicators function. You define indicator names, parameters and functions for your strategy. Indicators are defined as a separate step, as indicator calculation is performed only once and cached for the subsequent runs. See documentation.
  • Trading algorithm. Here you define decide_trades function that contains the trading strategy logic. It reads price data and indicator values for the current timestamp of the decision cycle. Then it outputs a list of trades. Trades are generic by PositionManager of which functions open_position and close_position are used to open individual trading positions.
  • Backtest: This section of the notebook runs the backtest. Here is a progress bar displayed about the current running backtest, and any errors you may encounter. We use function run_backtest_inline() that gives us the backtest's state Python object, which contains all the information about the backtest execution we can then analyse.
  • Output: You can have various visualisation and tables about the strategy performance. These include e.g. Equity curve, Performance metrics (max drawdown, Sharpe, etc) and Trading statistics.

This is a rough skeleton. You mix and match can easily add your own trading signals and output charts using with all tools available in Pandas and Jupyter notebook ecosystem. There aren't any limitations on what you can do.

Learning resources

Troubleshooting

Note to Mac users: The current Docker image is built for Intel platform. If you run Dev Container on your Mac computer with Visual Studio Code, the backtesting speed is slower than you would get otherwise.

Testing the Dev Container build:

devcontainer up --workspace-folder .

Checking installed packages wihtin Codespaces terminal:

pip list

Running the example notebooks using command line ipython (useful for debugging)

ipython notebooks/single-backtest/bitcoin-breakout-atr.ipynb

About

Start developing and backtesting your own automated trading strategies

tradingstrategy.ai

Topics

python ethereum jupyter-notebook pandas trading-strategies algorithmic-trading tradingbot solana

Resources

Readme
Activity
Custom properties

Stars

57 stars

Watchers

1 watching

Forks

9 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 3

Languages