introduction

Cette fois, j'ai essayé de créer un algorithme de méthode d'évasion à Quantx Factory fourni par Smart Trade Co., Ltd.

Auto-introduction

C'est le premier message de Qiita. Originaire de la préfecture de Kochi, je fréquente une université à Yokohama. Ma spécialité est la physique, la programmation est un peu utilisée dans les expériences universitaires, et je suis un débutant complet en Python (sueur) Je viens de commencer un stage chez Smart Trade l'autre jour, je voudrais donc mettre à jour ce que j'ai appris en tant que sortie au besoin.

Qu'est-ce qu'une évasion?

La cassure consiste à percer les points ** dont de nombreux acteurs du marché sont conscients, tels que les lignes de résistance, les lignes de support et les prix les plus élevés.

En gros, après la cassure, il y a une habitude d'aller à un prix plus élevé (moins cher).

Avantages et inconvénients de la méthode de cassure

·mérite

Dans un marché fort, vous pouvez réaliser des bénéfices sans délai. (Fort contre les tendances)

·Démérite

Si vous ne parvenez pas à casser parce que vous prenez une position dans la fourchette de prix élevée (tromperie), la réduction des pertes a tendance à être importante.

Signal compte tenu des inconvénients

Après avoir cassé le prix élevé des 10 derniers jours, récupérez l'endroit où vous avez poussé 50% ou plus par rapport à la fourchette de prix des 10 jours. De plus, afin d'éviter toute déception, la force de la tendance est jugée à l'aide de l'indice technique ADX. (Pour le cours de clôture, la valeur ajustée pour le fractionnement d'actions est utilisée.)

Mode de paiement

Règlement au moment où le dernier prix bas a été mis à jour De plus, pour la gestion des fonds, nous réglons également en fonction du taux d'augmentation et de diminution.

code

Copie ↑ Veuillez partager.

import maron
import pandas as pd
import numpy as np
import talib as ta

ot = maron.OrderType.MARKET_OPEN   #Commande au moment du cours d'ouverture le lendemain de l'émission du signal

def initialize(ctx):
    #Réglage
    ctx.logger.debug("initialize() called")

    #Combien de jours dans le passé observer
    ctx.high_term = 10
    ctx.low_term = 10
    ctx.vol_term = 10
    #Quel pourcentage avez-vous pour votre poste
    ctx.target = 0.5 
    
    ctx.configure(
      channels={          #Canal utilisé
        "jp.stock": {
          "symbols": [
            "jp.stock.7203",
            "jp.stock.9984",
            "jp.stock.8306",
            "jp.stock.4502",
            "jp.stock.6758",
            "jp.stock.6861",
            "jp.stock.9432",
            "jp.stock.8316",
            "jp.stock.7267",
            "jp.stock.8411",
            "jp.stock.6098",
            "jp.stock.7974",
            "jp.stock.9433",
            "jp.stock.9022",
            "jp.stock.8058",
            "jp.stock.4452",
            "jp.stock.8766",
            "jp.stock.6954",
            "jp.stock.6981",
            "jp.stock.9020",
            "jp.stock.4063",
            "jp.stock.7751",
            "jp.stock.6501",
            "jp.stock.3382",
            "jp.stock.9437",
            "jp.stock.8031",
            "jp.stock.4503",
            "jp.stock.8802",
            "jp.stock.6752",
          ],
          "columns": [
            "high_price_adj",
            "low_price_adj",
            "close_price_adj"
            "volume_adj",
            ]}})  

    def _BREAK_NEW_HIGH(data):

      #Remplissez les valeurs manquantes
      hp = data["high_price_adj"].fillna(method="ffill")
      lp = data["low_price_adj"].fillna(method="ffill")
      cp = data["close_price_adj"].fillna(method="ffill")
      vol = data["volume_adj"].fillna(method="ffill")
      #Obtenez le prix le plus élevé des 10 derniers jours
      new_max = hp.rolling(window=ctx.high_term, center=False).max()
      new_min = lp.rolling(window=ctx.low_term, center=False).min()
      vol_max = vol.rolling(window=ctx.vol_term, center=False).max()
      #Authenticité de savoir si le prix le plus élevé est le même que le prix élevé actuel
      today_is_new_high = new_max == hp
      today_is_new_low = new_min == lp
      today_is_vol_max = vol_max == vol

      price_range = new_max - new_min   #échelle des prix
      
      ADX = pd.DataFrame(data=0,columns=cp.columns, index=cp.index)
      
      for (sym,val) in cp.items():
        ADX[sym] = ta.ADX(hp[sym], lp[sym], cp[sym], timeperiod=14)
      
      buy_sig1 = (new_max - lp) > price_range*0.5
      buy_sig2 = ADX > 32
      buy_sig = (buy_sig1) & (buy_sig2)
      sell_sig = lp < new_min
      
      # market_Créez un bloc de données appelé sig qui contient tous les 0
      market_sig = pd.DataFrame(data=0.0, columns=hp.columns, index=hp.index)
  
      # buy_1 quand sig est vrai.0、sell_Quand sig est vrai-1.Mettre à 0
      market_sig[buy_sig == True] = 1.0
      market_sig[sell_sig == True] = -1.0
      market_sig[(buy_sig == True) & (sell_sig == True)] = 0.0
    
      return {
        "ADX":ADX, 
        "New High":new_max, 
        "New Low":new_min,
        "price range":price_range,
        "market:sig": market_sig,
        }

    #Enregistrement du signal
    ctx.regist_signal("BREAK_NEW_HIGH", _BREAK_NEW_HIGH)
    
def handle_signals(ctx, date, current):    
   
    market_sig = current["market:sig"]

    done_syms = set([])
  
    #Réduction des pertes, établissement des bénéfices
    for (sym, val) in ctx.portfolio.positions.items():
      returns = val["returns"]
      if returns < -0.025:
        sec = ctx.getSecurity(sym)
        sec.order(-val["amount"], comment="Coupe de perte(%f)" % returns)
        done_syms.add(sym)
      elif returns > 0.07:
        sec = ctx.getSecurity(sym)
        sec.order(-val["amount"], comment="Vente à but lucratif(%f)" % returns)
        done_syms.add(sym)
  
    #Acheter signal
    buy = market_sig[market_sig > 0.0]
    for (sym, val) in buy.items():
      if sym in done_syms:
        continue
  
      sec = ctx.getSecurity(sym)
      sec.order(sec.unit() * 1.5,orderType=ot, comment="SIGNAL BUY")
      # ctx.logger.debug("BUY: %s,  %f" % (sec.code(), val))
      pass
  
    #Signal de vente
    sell = market_sig[market_sig < 0.0]
    for (sym, val) in sell.items():
      if sym in done_syms:
        continue
      sec = ctx.getSecurity(sym)
      sec.order(sec.unit() * -1.5,orderType=ot, comment="SIGNAL SELL")
      #ctx.logger.debug("SELL: %s,  %f" % (sec.code(), val))
      pass

Résultat d'exécution

結果ブレイクアウト　.PNG

J'ai backtesté le prix du marché au cours des 3 dernières années.

Ratio profits / pertes: 77,71% Tirage maximum: 10,1% Rapport net: 1,682 Volatilité: 0.123 α : 0.162 β : 0.525

Impressions / Discussion

Le résultat en lui-même n'est pas mauvais, mais le nombre de transactions était beaucoup plus élevé que ce à quoi je m'attendais. Probablement parce qu'il y a beaucoup de pyramidage (achat supplémentaire). (Peut-être que vous pouvez échanger un peu moins souvent)

Comme point d'amélioration, ・ Supprimez un peu plus DD ・ Examen des points d'entrée ・ Mise en place de la gestion de portefeuille ・ Cela ne dépend pas beaucoup de la marque

Est-ce que c'est l'endroit ...

S'il peut être amélioré, je le corrigerai le cas échéant. (Date de rédaction de l'article 2020/2/17)

Site de référence

・ Qu'est-ce que le ratio net, le DD maximum et la volatilité? [Regardez l'index de l'algorithme comme ceci! ] https://blog.quantx.io/2019/03/25/yenzo-algo-erabikata/

・ Nouvel algorithme de mise à jour des prix élevés #QuantX https://qiita.com/shinseitaro/items/a098d99f15e99ac3e0c3

Clause de non-responsabilité Précautions

Veuillez noter que nous ne sommes pas responsables des gains ou pertes encourus dans les transactions réelles utilisant ce code ou ces connaissances.

[PYTHON] J'ai essayé de mettre en œuvre une évasion (type d'évitement de tromperie) avec Quantx