bibliothèque de commerce d'algorithmes python

bibliothèque de commerce d'algorithmes python

Je voudrais présenter quelques bibliothèques de trading d'algorithmes de python. J'ai étudié les quatre éléments suivants cette fois.

• zipline
• PyAlgoTrade
• pybacktest
• backtrader

zipline github est la bibliothèque avec le plus d'étoiles parmi les trois. Comme référence pour savoir comment l'utiliser, jetons un coup d'œil au code de trading d'algorithme utilisant DMA, qui est également dans l'exemple.

import pytz
from datetime import datetime
import zipline as zp

start = datetime(1990, 1, 1, 0, 0, 0, 0, pytz.utc)
end = datetime(2002, 1, 1, 0, 0, 0, 0, pytz.utc)
data = zp.utils.factory.load_from_yahoo(stocks=['AAPL'], indexes={}, start=start,
                                        end=end, adjusted=False)

class DualMovingAverage(zp.TradingAlgorithm):
    def initialize(self, short_window=100, long_window=400):
        self.add_transform(zp.transforms.MovingAverage, 'short_mavg', ['price'],
                           window_length=short_window)

        self.add_transform(zp.transforms.MovingAverage, 'long_mavg', ['price'],
                           window_length=long_window)
        self.invested = False

    def handle_data(self, data):
        short_mavg = data['AAPL'].short_mavg['price']
        long_mavg = data['AAPL'].long_mavg['price']
        buy = False
        sell = False

        if short_mavg > long_mavg and not self.invested:
            self.order('AAPL', 100)
            self.invested = True
            buy = True
        elif short_mavg < long_mavg and self.invested:
            self.order('AAPL', -100)
            self.invested = False
            sell = True

        self.record(short_mavg=short_mavg,
                    long_mavg=long_mavg,
                    buy=buy,
                    sell=sell)


import matplotlib.pyplot as plt
dma = DualMovingAverage()
perf = dma.run(data)
fig = plt.figure()
ax1 = fig.add_subplot(211,  ylabel='Price in $')
data['AAPL'].plot(ax=ax1, color='r', lw=2.)
perf[['short_mavg', 'long_mavg']].plot(ax=ax1, lw=2.)

ax1.plot(perf.ix[perf.buy].index, perf.short_mavg[perf.buy],
         '^', markersize=10, color='m')
ax1.plot(perf.ix[perf.sell].index, perf.short_mavg[perf.sell],
         'v', markersize=10, color='k')

ax2 = fig.add_subplot(212, ylabel='Portfolio value in $')
perf.portfolio_value.plot(ax=ax2, lw=2.)

ax2.plot(perf.ix[perf.buy].index, perf.portfolio_value[perf.buy],
         '^', markersize=10, color='m')
ax2.plot(perf.ix[perf.sell].index, perf.portfolio_value[perf.sell],
         'v', markersize=10, color='k')

plt.legend(loc=0)
plt.gcf().set_size_inches(14, 10)
plt.show()

En regardant le code, les données historiques du cours de l'action sont obtenues à l'aide de la fonction zp.utils.factory.load_from_yahoo. Celui-ci est de type «pandas.DataFrame» et a la même structure que les données de cours de bourse qui peuvent être obtenues avec «pandas». La partie principale de l'algorithme est créée en héritant de la classe zp.TradingAlgorithm. En décrivant le traitement à effectuer pour chaque fois du cours de l'action dans la fonction «handle_data» et en attribuant la valeur à la fonction «record», il est possible de récupérer les données nécessaires à la représentation graphique des résultats. Je suis. Concernant les indicateurs techniques, la tyrolienne elle-même a quelques fonctions de calcul d'indicateurs, mais en installant ta-lib, vous pouvez utiliser des indicateurs plus variés. Sera.

PyAlgoTrade L'utilisation est similaire à la tyrolienne, mais elle semble être capable de gérer le commerce en direct de pièces de monnaie et d'événements Twitter. Jetons également un œil au code pour le trading d'algorithmes utilisant des bandes de bandes dans des échantillons.

from pyalgotrade import strategy
from pyalgotrade import plotter
from pyalgotrade.tools import yahoofinance
from pyalgotrade.technical import bollinger
from pyalgotrade.stratanalyzer import sharpe


class BBands(strategy.BacktestingStrategy):
    def __init__(self, feed, instrument, bBandsPeriod):
        strategy.BacktestingStrategy.__init__(self, feed)
        self.__instrument = instrument
        self.__bbands = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)

    def getBollingerBands(self):
        return self.__bbands

    def onBars(self, bars):
        lower = self.__bbands.getLowerBand()[-1]
        upper = self.__bbands.getUpperBand()[-1]
        if lower is None:
            return

        shares = self.getBroker().getShares(self.__instrument)
        bar = bars[self.__instrument]
        if shares == 0 and bar.getClose() < lower:
            sharesToBuy = int(self.getBroker().getCash(False) / bar.getClose())
            self.marketOrder(self.__instrument, sharesToBuy)
        elif shares > 0 and bar.getClose() > upper:
            self.marketOrder(self.__instrument, -1*shares)


def main(plot):
    instrument = "yhoo"
    bBandsPeriod = 40

    # Download the bars.
    feed = yahoofinance.build_feed([instrument], 2011, 2012, ".")

    strat = BBands(feed, instrument, bBandsPeriod)
    sharpeRatioAnalyzer = sharpe.SharpeRatio()
    strat.attachAnalyzer(sharpeRatioAnalyzer)

    if plot:
        plt = plotter.StrategyPlotter(strat, True, True, True)
        plt.getInstrumentSubplot(instrument).addDataSeries("upper", strat.getBollingerBands().getUpperBand())
        plt.getInstrumentSubplot(instrument).addDataSeries("middle", strat.getBollingerBands().getMiddleBand())
        plt.getInstrumentSubplot(instrument).addDataSeries("lower", strat.getBollingerBands().getLowerBand())

    strat.run()
    print "Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05)

    if plot:
        plt.plot()


if __name__ == "__main__":
    main(True)

Comme la tyrolienne, elle hérite de la classe strategy.BacktestingStrategy pour créer la partie principale du commerce. Par rapport à «tyrolienne», diverses fonctions de tracé de données sont préparées et je pense que c'est pratique.

pybacktest C'est une bibliothèque légère comparée aux deux bibliothèques ci-dessus. Jetons un coup d'œil à l'exemple de code réel.

import pybacktest
import pandas as pd

ohlc = pybacktest.load_from_yahoo('SPY')
ohlc.tail()

short_ma = 50
long_ma = 200

ms = pd.rolling_mean(ohlc.C, short_ma)
ml = pd.rolling_mean(ohlc.C, long_ma)
    
buy = cover = (ms > ml) & (ms.shift() < ml.shift())  # ma cross up
sell = short = (ms < ml) & (ms.shift() > ml.shift())  # ma cross down

bt = pybacktest.Backtest(locals(), 'ma_cross')

import pylab
bt.plot_trades()
pd.rolling_mean(ohlc.C, short_ma).plot(c='green')
pd.rolling_mean(ohlc.C, long_ma).plot(c='blue')
pylab.legend(loc='upper left')
pylab.show()

Vous pouvez voir que le code est plus court que les deux ci-dessus. La classe qui effectue les backtests est pybacktest.Backtest, mais avant cela, les données chronologiques des signaux d'achat et de vente sont obtenues à l'avance. Il n'y a pas de fonctions telles que le calcul d'indicateurs techniques, et cela ressemble à une bibliothèque qui résume simplement les fonctions.

backtrader

from datetime import datetime
import backtrader as bt
    
class SmaCross(bt.SignalStrategy):
    def __init__(self):
        sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
        crossover = bt.ind.CrossOver(sma1, sma2)
        self.signal_add(bt.SIGNAL_LONG, crossover)
    
cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)
    
data0 = bt.feeds.YahooFinanceData(dataname='YHOO', fromdate=datetime(2011, 1, 1),
                                  todate=datetime(2012, 12, 31))
cerebro.adddata(data0)
   
cerebro.run()
cerebro.plot()

Autre

Il s'agit d'une bibliothèque de trading d'algorithmes python trouvée ailleurs. ultra-finance QSTK