[PYTHON] Probieren Sie den Cloud-basierten Algorithmus-Handelsdienst "Quantopian" aus

Über diesen Artikel

Ich habe "Quantopian" gefunden, als ich in Python nach finanzbezogenen Informationen gesucht habe, also werde ich es versuchen. Quantopian

Was ist Quantopian?

Eine Cloud-basierte Algorithmus-Handelsplattform. Benutzer können Handelsalgorithmen mit Python-ähnlichem Code mithilfe einer dedizierten IDE (Entwicklungsumgebung) im Browser und im Backtest erstellen. Wenn Sie ein Konto bei Interactive Brokers Securities haben, können Sie anscheinend auch eine Verbindung herstellen und echte Trades tätigen.

Was können Sie handeln?

Es scheint minutenweise Daten zu US-Aktien / ETFs seit 2002 zu enthalten.

Lass uns beginnen mit

Kontoregistrierung

Greifen Sie auf die Site zu. Es ist hellrot. Registrieren Sie sich mit Ihrer E-Mail-Adresse über Anmelden oben rechts. quantopian_01.png

Sofort nach dem Login

Die Menüs sind oben aufgereiht. quantopian_02.png

Sie können den laufenden / bevorstehenden Wettbewerb (Vorwärtstest) unter Capital-> Leaderboard sehen. Es scheint, dass der Wettbewerb alle 6 Monate stattfindet. quantopian_05.png

Wenn Sie dem Namen folgen, können Sie sehen, was die Person in der Community gepostet hat und welchen Algorithmus sie geteilt hat. quantopian_06.png

Sie können auch die Leistung und den Quellcode des gemeinsam genutzten Algorithmus anzeigen und zur Verbesserung klonen. Das ist wie bei GitHub. quantopian_07.png

quantopian_08.png

Der Algorithmus ist aus dem Algorithmus codiert. quantopian_03.png

Wie schreibt man den Code?

Lesen wir den Beispielalgorithmus für die mittlere Umkehrung des Beispiels. Unten werde ich vorerst den vollständigen Code veröffentlichen.

python



# This is a sample mean-reversion algorithm on Quantopian for you to test and adapt.

# Algorithm investment thesis: 
# Top-performing stocks from last week will do worse this week, and vice-versa.

# Every Monday, we rank high-volume stocks based on their previous 5 day returns. 
# We go long the bottom 20% of stocks with the WORST returns over the past 5 days.
# We go short the top 20% of stocks with the BEST returns over the past 5 days.

# This type of algorithm may be used in live trading and in the Quantopian Open.

# Import the libraries we will use here
import numpy as np

# The initialize function is the place to set your tradable universe and define any parameters. 
def initialize(context):
    # Use the top 1% of stocks defined by average daily trading volume.
    set_universe(universe.DollarVolumeUniverse(99, 100))
    
    # Set execution cost assumptions. For live trading with Interactive Brokers 
    # we will assume a $1.00 minimum per trade fee, with a per share cost of $0.0075. 
    set_commission(commission.PerShare(cost=0.0075, min_trade_cost=1.00))
    
    # Set market impact assumptions. We limit the simulation to 
    # trade up to 2.5% of the traded volume for any one minute,
    # and  our price impact constant is 0.1. 
    set_slippage(slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.10))
    
    # Define the other variables
    context.long_leverage = 0.5
    context.short_leverage = -0.5
    context.lower_percentile = 20
    context.upper_percentile = 80
    context.returns_lookback = 5
           
    # Rebalance every Monday (or the first trading day if it's a holiday).
    # At 11AM ET, which is 1 hour and 30 minutes after market open.
    schedule_function(rebalance, 
                      date_rules.week_start(days_offset=0),
                      time_rules.market_open(hours = 1, minutes = 30))  

# The handle_data function is run every bar.    
def handle_data(context,data):    
    # Record and plot the leverage of our portfolio over time. 
    record(leverage = context.account.leverage)

    # We also want to monitor the number of long and short positions 
    # in our portfolio over time. This loop will check our positition sizes 
    # and add the count of longs and shorts to our plot.
    longs = shorts = 0
    for position in context.portfolio.positions.itervalues():
        if position.amount > 0:
            longs += 1
        if position.amount < 0:
            shorts += 1
    record(long_count=longs, short_count=shorts)

# This rebalancing is called according to our schedule_function settings.     
def rebalance(context,data):
    # Get the last N days of prices for every stock in our universe.
    prices = history(context.returns_lookback, '1d', 'price')
    
    # Calculate the past 5 days' returns for each security.
    returns = (prices.iloc[-1] - prices.iloc[0]) / prices.iloc[0]
    
    # Remove stocks with missing prices.
    # Remove any stocks we ordered last time that still have open orders.
    # Get the cutoff return percentiles for the long and short portfolios.
    returns = returns.dropna()
    open_orders = get_open_orders()
    if open_orders:
        eligible_secs = [sec for sec in data if sec not in open_orders]
        returns = returns[eligible_secs]

    # Lower percentile is the threshhold for the bottom 20%, upper percentile is for the top 20%.
    lower, upper = np.percentile(returns, [context.lower_percentile,
                                           context.upper_percentile])
    
    # Select the X% worst performing securities to go long.
    long_secs = returns[returns <= lower]
    
    # Select the Y% best performing securities to short.
    short_secs = returns[returns >= upper]
    
    # Set the allocations to even weights in each portfolio.
    long_weight = context.long_leverage / len(long_secs)
    short_weight = context.short_leverage / len(short_secs)
    
    for security in data:
        
        # Buy/rebalance securities in the long leg of our portfolio.
        if security in long_secs:
            order_target_percent(security, long_weight)
            
        # Sell/rebalance securities in the short leg of our portfolio.
        elif security in short_secs:
            order_target_percent(security, short_weight)
            
        # Close any positions that fell out of the list of securities to long or short.
        else:
            order_target(security, 0)
            
    log.info("This week's longs: "+", ".join([long_.symbol for long_ in long_secs.index]))
    log.info("This week's shorts: "  +", ".join([short_.symbol for short_ in short_secs.index]))

Überblick

Der Stichprobenalgorithmus zielt auf die sogenannte "Rückkehrumkehr" ab (ein Phänomen, bei dem eine relative Abnahme erhöht und eine Zunahme gemäß dem Gesetz der durchschnittlichen Regression verringert wird). Die Strategie ist wie folgt.

initialize(context) Ich werde es zuerst als Versprechen schreiben. `context``` hat die Aufgabe, Parameter usw. während der Handelssitzung zu verwalten. Mit anderen Worten, es funktioniert wie eine globale Variable. Stellen Sie die Parameter wie `context.some_property``` ein.

python


    # Use the top 1% of stocks defined by average daily trading volume.
    set_universe(universe.DollarVolumeUniverse(99, 100))

Definieren Sie zunächst das Anlageuniversum. Wir haben 99-100% des Perzentilranges des Transaktionsbetrags erworben. Mit anderen Worten, es ist die oberste 1% des Transaktionsbetrags.

python


    # Set execution cost assumptions. For live trading with Interactive Brokers 
    # we will assume a $1.00 minimum per trade fee, with a per share cost of $0.0075. 
    set_commission(commission.PerShare(cost=0.0075, min_trade_cost=1.00))

Die Gebühr beträgt 0,75 Cent pro Aktie bei einem Minimum von 1 USD.

python


    # Set market impact assumptions. We limit the simulation to 
    # trade up to 2.5% of the traded volume for any one minute,
    # and  our price impact constant is 0.1. 
    set_slippage(slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.10))

Definiert die Auswirkungen von Schlupf und Marktauswirkungen. `volume_limit bloß` ist, wie viel Sie Ihre Bestellmenge auf Minutenbasis gegen das Volumen halten möchten. Wenn beispielsweise 100 Aktien auf Minutenbasis gehandelt werden, ist` volume_limit = 0.25 Mit wird berechnet, dass bis zu 25 Aktien (100 * 0,25) für eine Minute ausgeführt werden können. Die tatsächlichen Auswirkungen auf den Markt (Preisschwankungen aufgrund Ihrer Bestellung) werden anhand der Konstante `` price_impact only berechnet. In Quantopian wird die Marktauswirkung durch (Ihre Bestellung / Volumen) ^ 2 * -Konstante berechnet. Im obigen Beispiel bewegt sich Ihre Bestellung beispielsweise (0,25) ^ 2 * 0,10 = 0,625%, was ein Nachteil ist. Es wird sein.

python


    # Define the other variables
    context.long_leverage = 0.5
    context.short_leverage = -0.5
    context.lower_percentile = 20
    context.upper_percentile = 80
    context.returns_lookback = 5

Definition der in Handelssitzungen verwendeten Konstanten. Beide Long- / Short-Positionen definieren bis zu 50% der Fonds, niedrigere / obere Perzentilwerte und vergangene Renditemessperioden.

python


    # Rebalance every Monday (or the first trading day if it's a holiday).
    # At 11AM ET, which is 1 hour and 30 minutes after market open.
    schedule_function(rebalance, 
                      date_rules.week_start(days_offset=0),
                      time_rules.market_open(hours = 1, minutes = 30))

Beschreibt den Prozess, der regelmäßig ausgeführt werden soll. Die Funktion `` `Neuausgleich``` wird am ersten Tag der Woche, 1 Stunde und 30 Minuten nach dem Öffnen, aufgerufen. (Die Zeugenzeit für US-Aktien liegt zwischen 9:30 und 16:00 Uhr, daher wird sie um 11:00 Uhr ausgeführt.)

handle_data(context, data) Wird jedes Mal aufgerufen, wenn ein Handelsereignis (Balkenaktualisierung) auftritt. `data``` ist ein Wörterbuch, in dem Daten des Anlageuniversums gespeichert werden und dessen Schlüssel das Tesicker-Symbol ist. Beispiel: data [symbol ('toget')] ``, um die neuesten Google-Daten abzurufen.

python


# The handle_data function is run every bar.    
def handle_data(context,data):    
    # Record and plot the leverage of our portfolio over time. 
    record(leverage = context.account.leverage)

    # We also want to monitor the number of long and short positions 
    # in our portfolio over time. This loop will check our positition sizes 
    # and add the count of longs and shorts to our plot.
    longs = shorts = 0
    for position in context.portfolio.positions.itervalues():
        if position.amount > 0:
            longs += 1
        if position.amount < 0:
            shorts += 1
    record(long_count=longs, short_count=shorts)

Mit record () können Sie einen beliebigen Wert aufzeichnen und in das Diagramm ausgeben. In diesem Fall wird die Anzahl der gehebelten und Long / Short-Aktien erfasst und aufgezeichnet.

rebalance(context,data) Von Schedule_Funktion aufgerufen, werden hier die Gimmicks und Closures ausgeführt.

python


# This rebalancing is called according to our schedule_function settings.     
def rebalance(context,data):
    # Get the last N days of prices for every stock in our universe.
    prices = history(context.returns_lookback, '1d', 'price')

Geschichte ist eine eingebaute Funktion, Geschichte(bar_count, frequency, field, ffill=True)Angeben. Bar_Verwenden Sie count, um die Position einschließlich des aktuellen Fußes anzugeben, Frequenz, um das Intervall anzugeben, und Feld, um die zu erfassenden Daten anzugeben. In diesem Fall erhalten Sie den Preis vor 5 Tagen. Der Rückgabewert ist pandas.Im DataFrame-Format sind die Universumsmarken in Spaltenrichtung angeordnet.




#### **`python`**
```py

    # Calculate the past 5 days' returns for each security.
    returns = (prices.iloc[-1] - prices.iloc[0]) / prices.iloc[0]

Berechnen Sie die Rendite.

python


    # Remove stocks with missing prices.
    # Remove any stocks we ordered last time that still have open orders.
    # Get the cutoff return percentiles for the long and short portfolios.
    returns = returns.dropna()
    open_orders = get_open_orders()
    if open_orders:
        eligible_secs = [sec for sec in data if sec not in open_orders]
        returns = returns[eligible_secs]

Nach dem Ausschluss nicht kalkulierbarer Renditen gelten die gehandelten Aktien als handelsfähige Aktien.

python


    # Lower percentile is the threshhold for the bottom 20%, upper percentile is for the top 20%.
    lower, upper = np.percentile(returns, [context.lower_percentile,
                                           context.upper_percentile])
    
    # Select the X% worst performing securities to go long.
    long_secs = returns[returns <= lower]
    
    # Select the Y% best performing securities to short.
    short_secs = returns[returns >= upper]

Ersetzen Sie die Renditen der unteren 20% -Punkte und der oberen 20% -Punkte durch die unteren und oberen und filtern Sie die ursprünglichen "Renditen", um sie auf lange und kurze Aktien zu beschränken.

python


    # Set the allocations to even weights in each portfolio.
    long_weight = context.long_leverage / len(long_secs)
    short_weight = context.short_leverage / len(short_secs)

Die Positionsskala pro Ausgabe wird für jeden Long und Short festgelegt. Wenn es fünf Long-Aktien gibt, bedeutet dies, dass jeder Aktie eine Position des 0,1-fachen des Geldbetrags gewährt wird.

python


    for security in data:
        
        # Buy/rebalance securities in the long leg of our portfolio.
        if security in long_secs:
            order_target_percent(security, long_weight)
            
        # Sell/rebalance securities in the short leg of our portfolio.
        elif security in short_secs:
            order_target_percent(security, short_weight)
            
        # Close any positions that fell out of the list of securities to long or short.
        else:
            order_target(security, 0)
            
    log.info("This week's longs: "+", ".join([long_.symbol for long_ in long_secs.index]))
    log.info("This week's shorts: "  +", ".join([short_.symbol for short_ in short_secs.index]))

Für alle Universumsaktien bestellen wir die in long_secs und die in short_secs enthaltenen. `order_target_percent``` ist eine integrierte Funktion, die eine Bestellung aufgibt, sodass die angegebene Aktie das angegebene Gewicht im Portfolio hat. Wenn Sie beispielsweise bereits 5% der AAPL in Ihrem Portfolio haben und order_target_percent (Symbol ('AAPL'), 0.1) `` `ausführen, erhalten Sie 5% der Differenz. Ein solcher Ort ist schlau! Aktien, die weder long_secs noch short_secs sind, werden mit einem Gewicht von 0% geschlossen.

Geben Sie zum Schluss das Protokoll aus und beenden Sie den Vorgang.

Lassen Sie uns den Backtest durchführen

Sie können einen einfachen Backtest ausführen, indem Sie im Editor-Bildschirm Strg + B drücken. Es ist einfach, aber es dauert einige Zeit. quantopian_04.png

Sie können die Leistung im Vergleich zu S & P500 (SPY) und den Beta-Drawdown für die Rückkehr überprüfen. Informationen zu langen und kurzen Marken werden auch auf dem Protokollbildschirm angezeigt. Sie können Full Backtest ausführen, um eine detailliertere Überprüfung zu erhalten. (Es dauert ungefähr ein paar Minuten)

quantopian_09.png

quantopian_10.png

Die Rendite beträgt 9,2%, was einer Outperformance gegenüber SPY-2,5% entspricht. Diese Strategie ist Beta 0,01, funktioniert also überhaupt nicht mit SPY. Der maximale Drawdown betrug rund 7%. Sie können auch das scharfe Verhältnis, das Saltino-Verhältnis, das Informationsverhältnis usw. sehen. Die Hebelwirkung während des Zeitraums liegt bei 0,95 bis 0,05, was nahezu marktneutral zu sein scheint.

Wenn Sie sich die Transaktionsdetails ansehen, können Sie auch den Handelsverlauf anzeigen.

abschließend

Ich habe vorerst nur versucht, den Beispielalgorithmus auszuführen, aber als ich mir die API-Dokumentation usw. ansah, stellte ich fest, dass es sich um eine ziemlich umfangreiche Algorithmus-Handelsplattform handelt. Bisher ging es beim Systemhandel oft darum, Daten selbst zu sammeln, Modelle zu erstellen und handelsübliche Software zu verwenden. In Zukunft ist es jedoch möglicherweise an der Zeit, dies in der Cloud zu tun. Vor allem finde ich es großartig, dass Sie Ihre Python-Codierungsfähigkeiten so einsetzen können, wie sie sind.

Es scheint, dass dasselbe in der lokalen Umgebung mit einem Paket namens zipline möglich ist, aber leider ist es nur mit Linux und OSX kompatibel, sodass es nicht in meiner Umgebung installiert werden kann.

In Zukunft möchte ich mit dem Lesen der API fortfahren.

Referenzseite

Es scheint noch fast keine Informationen auf Japanisch zu geben.

Quantopian - FinTech-Nachrichten, mit denen Sie Handelsalgorithmen in Ihrem Browser erstellen und testen können

Recommended Posts

Probieren Sie den Cloud-basierten Algorithmus-Handelsdienst "Quantopian" aus
Probieren Sie den Variational-Quantum-Eigensolver (VQE) -Algorithmus mit Blueqat aus
Probieren Sie den Taxii-Server aus (2. Service- / Erfassungseinstellungen)
Ich untersuchte den stärkenden Lernalgorithmus des Algorithmushandels
Über den Servicebefehl
Versuchen Sie, eine multimodale Verteilung mithilfe des EM-Algorithmus zu modellieren