Building Your First Algorithmic Strategy in Zipline

Building your first algorithmic strategy using Zipline can be both an exciting and insightful journey into the world of algorithmic trading. Zipline is a Pythonic algorithmic trading library that provides a powerful environment for backtesting trading strategies.

Getting Started with Zipline

To begin your journey, you'll first need to set up your development environment. You'll need Python installed on your machine, preferably version 3.5 to 3.7, as Zipline is traditionally more stable on these versions.
First, create a new virtual environment:

python -m venv zipline_env

Activate the environment:

# On macOS and Linux
git activate zipline_env/bin/activate

# On Windows
git activate zipline_env\Scripts\activate

Install Zipline within this environment:

pip install zipline-reloaded

With Zipline installed, you're ready to create your first algorithmic strategy.

Creating a Simple Moving Average Crossover Strategy

The first strategy we'll create is the classic simple moving average (SMA) crossover strategy. This strategy generates buy and sell signals based on the moving averages of the price movements.

Open a new script file, first_strategy.py, and import the necessary modules:

import zipline as zl
from zipline.api import order, symbol, record, history
import pandas as pd
import matplotlib.pyplot as plt

Next, define the main strategy function, named initialize:

def initialize(context):
    # Define portfolio assets
    context.asset = symbol('AAPL')

    # Set short and long moving average lengths
    context.short_window = 40
    context.long_window = 100

Now, add the strategy’s logic in the handle_data function:

def handle_data(context, data):
    # Request window history
    short_mavg = data.history(context.asset, 'price', context.short_window, '1d').mean()
    long_mavg = data.history(context.asset, 'price', context.long_window, '1d').mean()

    # Check for buy signals
    if short_mavg > long_mavg:
        # Log and Buy
        order(context.asset, 10)
        print("Buying Order Executed")

    # Check for sell signals
    elif short_mavg < long_mavg:
        # Log and Sell
        order(context.asset, -10)
        print("Selling Order Executed")

    # Record values for analysis
    record(AAPL=data.current(context.asset, "price"),
           short_mavg=short_mavg,
           long_mavg=long_mavg)

Backtesting the Strategy

We can now run this setup in Zipline's backtester. You'll need historical data for the assets you're trading. Zipline includes support for various data bundle providers.

We'll make a basic backtest using historical data by scheduling an execution:

from zipline.data import bundles
from zipline import run_algorithm
test_bundle = bundles.load("quandl")

start_date = pd.Timestamp('2015-01-01', tz='utc')
end_date = pd.Timestamp('2020-01-01', tz='utc')

performance = run_algorithm(start=start_date, end=end_date,
                             capital_base=10000,
                             initialize=initialize,
                             handle_data=handle_data,
                             bundle='quandl')

Analyzing the Results

Finally, to analyze the result of our backtest, we'll plot the performance:

# Visualizing portfolio performance
def analyze(performance):
    perf_rev = performance.round(2)
    plt.figure(figsize=(12,8))
    plt.plot(perf_rev.index, perf_rev['portfolio_value'])
    plt.xlabel('Date')
    plt.ylabel('Portfolio Value')
    plt.title('Portfolio Value Over Time')
    plt.show()

analyze(performance)

Running this script will simulate trading based on the defined strategy using historical data, recording all transactions and their resultant portfolio value for analysis.

Conclusion

And there you go! You have successfully written and backtested an algorithmic trading strategy with Zipline. This introduces you to the concepts necessary for algorithmic trading. As you dive deeper, consider exploring more complex algorithms, integrating more data, or incorporating risk management techniques for more robust strategies.