Ceci est une continuation de Dernière fois.

LESSON 11 Putting It All Together Mobilisons tout ce que nous avons appris jusqu'à présent pour mettre en œuvre une [stratégie de retour à la moyenne] simple (http://www.investopedia.com/terms/m/meanreversion.asp) [^ 1].

Planning the Strategy Tout d'abord, faisons un plan stratégique. Si la moyenne mobile simple à 10 jours (ci-après SMA) est supérieure à la SMA à 30 jours, le cours de l'action baissera et vice versa, le cours de l'action augmentera. Il tire parti de la nature de la régression moyenne.

Selecting Assets to Trade Ce type de stratégie utilise généralement pipeline pour définir le stock, mais utilise le sid () que vous avez appris jusqu'à présent. Je vais. Le code ci-dessous définit 5 marques. [^ 2]

# MSFT, UNH, CTAS, JNS, COG
context.security_list = [sid(5061), sid(7792), sid(1941), sid(24556), sid(1746)]

Setting a Rebalance Schedule Le code ci-dessous exécute la fonction rebalance () (discutée ci-dessous) vers le début de la semaine.

schedule_function(rebalance,
                  date_rules.week_start(days_offset=0),
                  time_rules.market_open())

Computing Weights Calculez le poids du portefeuille. Selon la stratégie mentionnée ci-dessus, nous vendrons ou vendrons les actions qui remplissent les conditions.

SMA 10 jours> SMA 30 jours: court
SMA 10 jours <SMA 30 jours: Long

Dans le code ci-dessous, si la différence entre la SMA à 10 jours et la SMA à 30 jours est importante, le poids est augmenté et le tout est normalisé à 1.

def compute_weights(context, data):

  # Get the 30-day price history for each security in our list.
  hist = data.history(context.security_list, 'price', 30, '1d')

  # Create 10-day and 30-day trailing windows.
  prices_10 = hist[-10:]
  prices_30 = hist

  # 10-day and 30-day simple moving average (SMA)
  sma_10 = prices_10.mean()
  sma_30 = prices_30.mean()

  # Weights are based on the relative difference between the short and long SMAs
  raw_weights = (sma_30 - sma_10) / sma_30

  # Normalize our weights
  normalized_weights = raw_weights / raw_weights.abs().sum()

  # Return our normalized weights. These will be used when placing orders later.
  return normalized_weights

Order Execution Le contenu de la fonction rebalance () programmée dans Setting a Rebalance Schedule. Le stock défini en fonction du poids calculé par la fonction ci-dessus compute_weights est long ou court.

def rebalance(context, data):

  # Calculate our target weights.
  weights = compute_weights(context, data)

  # Place orders for each of our securities.
  for security in context.security_list:
    if data.can_trade(security):
      order_target_percent(security, weights[security])

Recording and Plotting Enregistrez et visualisez le nombre de longs et courts métrages. Le code ci-dessous implémente le code d'enregistrement dans la fonction record_vars () et l'exécute dans la fonction schedule_function (). Prévu pour la fermeture quotidienne.

schedule_function(record_vars,
                  date_rules.every_day(),
                  time_rules.market_close())

Le contenu de la fonction record_vars () est le code suivant. Vous pouvez vérifier le nombre d'actions et le nombre de positions dans le portefeuille en vous référant à context.portfolio.positions. Ici, on compte simplement le nombre de longs et le nombre de shorts.

def record_vars(context, data):

  # Check how many long and short positions we have.
  longs = shorts = 0
  for position in context.portfolio.positions.itervalues():
    if position.amount > 0:
      longs += 1
    elif position.amount < 0:
      shorts += 1

  # Record our variables.
  record(leverage=context.account.leverage, long_count=longs, short_count=shorts)

Putting It Together Cette stratégie rééquilibre le portefeuille sur une base hebdomadaire et l'enregistre quotidiennement. Vous n'avez donc pas besoin de la fonction handle_data (), qui s'exécute toutes les minutes. Le code ci-dessus peut être résumé comme le code suivant. Vous pouvez cloner le code depuis ici.

def initialize(context):
    """
    initialize() is called once at the start of the program. Any one-time
    startup logic goes here.
    """

    # An assortment of securities from different sectors:
    # MSFT, UNH, CTAS, JNS, COG
    context.security_list = [sid(5061), sid(7792), sid(1941), sid(24556), sid(1746)]

    # Rebalance every Monday (or the first trading day if it's a holiday)
    # at market open.
    schedule_function(rebalance,
                      date_rules.week_start(days_offset=0),
                      time_rules.market_open())

    # Record variables at the end of each day.
    schedule_function(record_vars,
                      date_rules.every_day(),
                      time_rules.market_close())

def compute_weights(context, data):
    """
    Compute weights for each security that we want to order.
    """

    # Get the 30-day price history for each security in our list.
    hist = data.history(context.security_list, 'price', 30, '1d')

    # Create 10-day and 30-day trailing windows.
    prices_10 = hist[-10:]
    prices_30 = hist

    # 10-day and 30-day simple moving average (SMA)
    sma_10 = prices_10.mean()
    sma_30 = prices_30.mean()

    # Weights are based on the relative difference between the short and long SMAs
    raw_weights = (sma_30 - sma_10) / sma_30

    # Normalize our weights
    normalized_weights = raw_weights / raw_weights.abs().sum()

    # Determine and log our long and short positions.
    short_secs = normalized_weights.index[normalized_weights < 0]
    long_secs = normalized_weights.index[normalized_weights > 0]

    log.info("This week's longs: " + ", ".join([long_.symbol for long_ in long_secs]))
    log.info("This week's shorts: " + ", ".join([short_.symbol for short_ in short_secs]))

    # Return our normalized weights. These will be used when placing orders later.
    return normalized_weights

def rebalance(context, data):
    """
    This function is called according to our schedule_function settings and calls
    order_target_percent() on every security in weights.
    """

    # Calculate our target weights.
    weights = compute_weights(context, data)

    # Place orders for each of our securities.
    for security in context.security_list:
        if data.can_trade(security):
            order_target_percent(security, weights[security])

def record_vars(context, data):
    """
    This function is called at the end of each day and plots our leverage as well
    as the number of long and short positions we are holding.
    """

    # Check how many long and short positions we have.
    longs = shorts = 0
    for position in context.portfolio.positions.itervalues():
        if position.amount > 0:
            longs += 1
        elif position.amount < 0:
            shorts += 1

    # Record our variables.
    record(leverage=context.account.leverage, long_count=longs, short_count=shorts)

en conclusion

Ceci termine le didacticiel 1. Il existe quatre Tutoriels en tout, et Tutorial 2 est une description de Pipeline. Nous pouvons faire le Tutoriel 2 si demandé, mais nous le terminerons pour le moment. Merci pour votre soutien.

LEÇON 10 <-> Continuer avec le didacticiel 2?

[^ 1]: également connue sous le nom de méthode d'annulation de retour. C'est une méthode qui utilise la nature de la régression moyenne pour contredire les actions qui s'écartent de la valeur moyenne et essayer de faire un profit. [^ 2]: l'action sélectionnée n'a pas de signification particulière.

[PYTHON] Tutoriel Quantopian LEÇON 11

en conclusion