[PYTHON] Essayez le service de trading d'algorithmes basé sur le cloud "Quantopian"
À propos de cet article
J'ai trouvé "Quantopian" lorsque je cherchais des informations financières en Python, donc je vais l'essayer. Quantopian
Qu'est-ce que Quantopian
Une plateforme de trading d'algorithme basée sur le cloud. Les utilisateurs peuvent créer des algorithmes de trading avec du code de type Python en utilisant un IDE (environnement de développement) dédié dans le navigateur et un backtest. Si vous avez un compte chez Interactive Brokers Securities, il semble que vous puissiez également vous connecter et effectuer de véritables transactions.
Que pouvez-vous échanger?
Il semble contenir des données sur les actions américaines / ETF depuis 2002 sur une base infime.
Commençons avec
Enregistrement du Compte
Accédez au site. Il est rouge vif. Inscrivez-vous avec votre adresse e-mail depuis Inscription en haut à droite.
Immédiatement après la connexion
Les menus sont alignés en haut.
Vous pouvez voir le concours en cours / à venir (test avant) dans Capital-> Leaderboard. Il semble que le concours ait lieu tous les 6 mois.
Si vous suivez le nom, vous pouvez voir ce que la personne a publié dans la communauté et l'algorithme qu'il a partagé.
Vous pouvez également voir les performances et le code source de l'algorithme partagé et le cloner pour amélioration. C'est comme GitHub.
L'algorithme est codé à partir de l'algorithme.
Comment écrivez-vous le code?
Lisons l'exemple d'algorithme de réversion moyenne de l'échantillon. Ci-dessous, je publierai le code complet pour le moment.
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]))
Aperçu
L'algorithme d'échantillonnage vise ce qu'on appelle «l'inversion de retour» (un phénomène dans lequel une diminution relative est augmentée et une augmentation est diminuée selon la loi de régression moyenne). La stratégie est la suivante.
- Au début de chaque semaine, mesurez les rendements des 5 derniers jours pour les actions à volume élevé. --Long le stock des 20% inférieurs des rendements --Raccourcissez les 20% des retours
- Les marques qui ne sont pas devenues longues ou courtes seront fermées
- Les positions longues et courtes représentent 50% des fonds
initialize(context)
Je vais d'abord l'écrire comme une promesse. Le contexte '' a pour rôle de gérer les paramètres, etc. pendant la session commerciale. En d'autres termes, cela fonctionne comme une variable globale. Définissez les paramètres comme `` context.some_property```.
python
# Use the top 1% of stocks defined by average daily trading volume.
set_universe(universe.DollarVolumeUniverse(99, 100))
Tout d'abord, définissez l'univers d'investissement. Nous avons acquis 99 à 100% du rang centile du montant de la transaction. En d'autres termes, il s'agit du 1% supérieur du montant de la transaction.
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))
Les frais sont de 0,75 cents par action, avec un minimum de 1 $.
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))
Définit l'impact du glissement et l'impact sur le marché. volume_limit '' est simplement combien vous pouvez limiter la quantité de votre commande au volume sur une base minute. Par exemple, lorsque 100 actions sont négociées sur une base minute, `volume_limit = 0,25 Avec '', il est calculé que jusqu'à 25 actions (100 * 0,25) peuvent être exécutées pendant une minute.
L'impact réel sur le marché (fluctuations de prix dues à votre commande) est calculé en utilisant la constante `` price_impact simplement ''. Dans Quantopian, l'impact sur le marché est calculé par (votre commande / volume) ^ 2 * constante. Par exemple, dans l'exemple ci-dessus, votre commande se déplace de (0,25) ^ 2 * 0,10 = 0,625%, ce qui est un inconvénient. Ce sera.
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
Définition des constantes utilisées dans les sessions de trading. Les positions longues / courtes définissent jusqu'à 50% des fonds, les niveaux de centile inférieur / supérieur et les périodes de mesure du rendement passées.
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))
Décrit le processus à exécuter périodiquement. La fonction `` rééquilibrage '' est appelée le premier jour de la semaine, 1 heure et 30 minutes après l'ouverture. (L'heure du témoin des actions américaines est de 9h30 à 16h00, elle sera donc exécutée à 11h00)
handle_data(context, data)
Appelé à chaque fois qu'un événement commercial (mise à jour de la barre) se produit. data '' est un dictionnaire qui stocke les données d'univers d'investissement et dont la clé est le symbole Tesicker. Par exemple, data [symbol ('GOOG')] `` `pour obtenir les dernières données Google.
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)
Vous pouvez utiliser record () pour enregistrer n'importe quelle valeur et l'afficher dans le graphique. Dans ce cas, le nombre d'actions à effet de levier et long / short est enregistré et tracé.
rebalance(context,data) Appelés par schedule_function, les gadgets et les fermetures sont exécutés ici.
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')
l'histoire est une fonction intégrée, l'histoire(bar_count, frequency, field, ffill=True)Spécifier. bar_Spécifiez la position, y compris le pied actuel avec compte, l'intervalle avec la fréquence et les données à acquérir avec le champ. Dans ce cas, vous obtiendrez le prix il y a 5 jours. La valeur de retour est pandas.Au format DataFrame, les marques d'univers sont alignées dans le sens des colonnes.
#### **`python`**
```py
# Calculate the past 5 days' returns for each security.
returns = (prices.iloc[-1] - prices.iloc[0]) / prices.iloc[0]
Calculez le retour.
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]
Après avoir exclu les rendements non calculables, les actions échangées sont considérées comme des actions éligibles au commerce.
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]
Remplacez les rendements des points inférieurs de 20% et des points supérieurs de 20% par des points inférieurs et supérieurs, et filtrez les `` rendements '' d'origine pour les réduire aux actions longues et courtes.
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)
L'échelle de position par émission est déterminée pour chaque long et court. S'il y a cinq actions longues, cela signifie que chaque action a droit à une position de 0,1 fois le montant des fonds.
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]))
Pour tous les stocks de l'univers, nous commanderons ceux inclus dans long_secs et ceux inclus dans short_secs. Order_target_percent est une fonction intégrée qui passe une commande afin que l'action spécifiée ait le poids spécifié dans le portefeuille. Par exemple, si vous avez déjà 5% d'AAPL dans votre portefeuille et que vous exécutez ```order_target_percent (symbol ('AAPL'), 0.1) `` `, vous obtiendrez 5% de la différence. Un tel endroit est intelligent!
Les actions qui ne sont ni long_secs ni short_secs seront clôturées avec un poids de 0%.
Enfin, sortez le journal et terminez.
Faisons le back test
Vous pouvez exécuter un backtest simple en appuyant sur Ctrl + B sur l'écran de l'éditeur. C'est simple, mais cela prend du temps.
Vous pouvez vérifier les performances par rapport au S & P500 (SPY) et le tirage bêta de retour. Les informations sur les marques longues et courtes sont également affichées sur l'écran du journal. Vous pouvez exécuter un backtest complet pour une vérification plus détaillée. (Cela prend environ quelques minutes)
Le rendement est de 9,2%, ce qui est surperformant par rapport à SPY-2,5%. Cette stratégie est bêta 0.01, elle ne fonctionne donc pas du tout avec SPY. Le drawdown maximum était d'environ 7%. Vous pouvez également voir le rapport net, le rapport saltino, le rapport d'information, etc. L'effet de levier au cours de la période est d'environ 0,95 à 1,05, ce qui semble presque neutre sur le marché.
Si vous regardez les détails de la transaction, vous pouvez également voir l'historique des transactions.
en conclusion
J'ai juste essayé d'exécuter l'exemple d'algorithme pour le moment, mais quand j'ai regardé la documentation de l'API, etc., j'ai trouvé qu'il s'agissait d'une plate-forme de trading d'algorithme assez importante. Jusqu'à présent, le trading système consistait souvent à collecter des données par vous-même, à créer des modèles et à utiliser des logiciels disponibles dans le commerce, mais à l'avenir, il sera peut-être temps de le faire dans le cloud. Par-dessus tout, je pense que c'est génial que vous puissiez utiliser vos compétences en codage Python telles quelles.
Il semble que la même chose puisse être faite dans l'environnement local en utilisant un package appelé zipline, mais malheureusement, il n'est compatible qu'avec Linux et OSX, il ne peut donc pas être installé dans mon environnement.
À l'avenir, j'aimerais continuer à lire l'API.
Site de référence
Il ne semble pas encore y avoir d'informations en japonais.
Recommended Posts