Automated Trading, Zipline Basics

Hello! In this lecture, we will introduce the development of automated trading using Python, and how to build a basic automated trading system using the Zipline library. Automated trading is widely used in stock and cryptocurrency trading, where a system automatically makes buy or sell decisions based on algorithms grounded in technical analysis.

1. What is Automated Trading?

Automated trading is software that automatically makes investment decisions based on a pre-defined algorithm. It helps eliminate emotional factors that can affect decisions and encourages data-driven decision-making. Automated trading systems are utilized across various financial markets, including stock markets, futures, options, forex, and cryptocurrencies.

2. What is Zipline?

Zipline is a Python-based algorithmic trading library primarily developed for backtesting in the stock market. It supports integration with exchanges like Bitfinex to execute trades in real-time. Zipline provides a simple API that makes it easy to write and test algorithms.

2.1 Features of Zipline

  • Backtesting: Allows verification of algorithm performance using historical data.
  • Simple API: Offers user-friendly functions so analysts and developers can easily write and run algorithms.
  • Flexible Structure: Provides the flexibility to integrate with various data sources.

3. Installing Zipline

To use Zipline, you can install it using pip as follows:

pip install zipline

Once installation is complete, we need to prepare the dataset we will use. Zipline supports various data sources, but in this lecture, we will use an example that fetches stock price data from ‘Yahoo Finance’.

4. Basic Usage of Zipline

To understand the basic usage of Zipline, we will implement an automated trading strategy through a simple example. The example below shows a straightforward momentum-based trading strategy.

4.1 Example Code

The code below is just an example, calculating the 50-day moving average for a stock and executing a buy order when the current price exceeds the moving average, otherwise executing a sell order.


import zipline
from zipline.api import order, record, symbol
import pandas as pd
from datetime import datetime
from zipline import run_algorithm

def initialize(context):
    context.asset = symbol('AAPL')
    context.MA_length = 50

def handle_data(context, data):
    # Get historical data
    historical_data = data.history(context.asset, 'price', context.MA_length, '1d')

    # Calculate moving average
    moving_average = historical_data.mean()

    if data.current(context.asset, 'price') > moving_average:
        order(context.asset, 10)  # Buy 10 shares
    else:
        order(context.asset, -10)  # Sell 10 shares

    # Record values for later inspection
    record(price=data.current(context.asset, 'price'),
           moving_average=moving_average)

start = datetime(2020, 1, 1)
end = datetime(2021, 1, 1)

results = run_algorithm(start=start,
                         end=end,
                         initialize=initialize,
                         capital_base=10000,
                         handle_data=handle_data,
                         data_frequency='daily',
                         bundle='quantale')

4.2 Code Explanation

The above code consists of the following components:

  • initialize: Responsible for setting up the strategy and initializing parameters.
  • handle_data: A function called every trading day that decides on buying and selling.
  • data.history: Fetches historical data for a given period.
  • order: Executes buy and sell orders for specific assets.
  • record: Sets the values to record for each trading day.

5. Analyzing Backtest Results

Zipline periodically records trading results, and the final results dataframe can be used to analyze performance.


import matplotlib.pyplot as plt

# Plot the results
results.portfolio_value.plot()
plt.title('Portfolio Value Over Time')
plt.xlabel('Date')
plt.ylabel('Portfolio Value')
plt.show()

5.1 Interpreting Results

Using the code above, you can visually examine portfolio value over time. This graph allows you to evaluate the strategy’s performance at a glance.

6. Portfolio Basics and Additional Strategies

Having addressed a single asset example, let’s briefly explain how to manage a portfolio of various assets. Zipline allows concurrent operation of multiple assets, applying the same principles to set routines for each asset.

6.1 Portfolio Initialization


def initialize(context):
    context.assets = [symbol('AAPL'), symbol('GOOGL'), symbol('MSFT')]
    context.MA_length = 50

6.2 Multi-Asset Handling


def handle_data(context, data):
    for asset in context.assets:
        historical_data = data.history(asset, 'price', context.MA_length, '1d')
        moving_average = historical_data.mean()
        
        if data.current(asset, 'price') > moving_average:
            order(asset, 10)
        else:
            order(asset, -10)
        record(price=data.current(asset, 'price'),
               moving_average=moving_average)

7. Conclusion

We have explored the basic aspects of building an automated trading system using Zipline. Automated trading is a useful tool that can help eliminate emotional factors through data-driven decisions and improve investment performance. I encourage you to utilize Zipline to try various strategies and analyze performance.

I also recommend researching more advanced automated trading strategies combined with Zipline in the future. I hope the knowledge gained from this lecture aids you in your investment journey!