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

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.

Recommended Posts

J'ai essayé de mettre en œuvre une évasion (type d'évitement de tromperie) avec Quantx
J'ai essayé d'implémenter une ligne moyenne mobile de volume avec Quantx
J'ai essayé d'implémenter Autoencoder avec TensorFlow
J'ai essayé d'implémenter CVAE avec PyTorch
J'ai essayé d'implémenter la lecture de Dataset avec PyTorch
J'ai essayé d'implémenter PCANet
J'ai essayé d'implémenter StarGAN (1)
J'ai essayé d'implémenter Mine Sweeper sur un terminal avec python
J'ai essayé d'implémenter le perceptron artificiel avec python
J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
J'ai essayé d'implémenter SSD avec PyTorch maintenant (Dataset)
J'ai essayé d'implémenter Deep VQE
J'ai essayé de mettre en place une validation contradictoire
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai essayé de mettre en œuvre le chapeau de regroupement de Harry Potter avec CNN
J'ai essayé d'implémenter Realness GAN
J'ai essayé d'implémenter SSD avec PyTorch maintenant (édition du modèle)
J'ai essayé d'implémenter la classification des phrases par Self Attention avec PyTorch
J'ai essayé d'implémenter PLSA en Python
J'ai essayé d'implémenter la permutation en Python
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé de commencer avec Hy
J'ai essayé d'implémenter PLSA dans Python 2
J'ai essayé d'implémenter ADALINE en Python
J'ai essayé d'implémenter PPO en Python
J'ai essayé de résoudre TSP avec QAOA
J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy
J'ai essayé de mettre en œuvre une blockchain qui fonctionne réellement avec environ 170 lignes
J'ai essayé de prédire l'année prochaine avec l'IA
J'ai essayé d'utiliser lightGBM, xg boost avec Boruta
J'ai essayé de sauvegarder les données avec discorde
J'ai essayé de détecter rapidement un mouvement avec OpenCV
J'ai essayé d'intégrer Keras dans TFv1.1
J'ai essayé d'obtenir des données CloudWatch avec Python
J'ai essayé de sortir LLVM IR avec Python
J'ai essayé d'implémenter TOPIC MODEL en Python
J'ai essayé de détecter un objet avec M2Det!
J'ai essayé d'automatiser la fabrication des sushis avec python
J'ai essayé de prédire la survie du Titanic avec PyCaret
J'ai essayé d'utiliser Linux avec Discord Bot
J'ai essayé d'implémenter le tri sélectif en python
J'ai essayé d'étudier DP avec séquence de Fibonacci
J'ai essayé de démarrer Jupyter avec toutes les lumières d'Amazon
J'ai essayé de juger Tundele avec Naive Bays
J'ai essayé de mettre en œuvre le problème du voyageur de commerce
J'ai essayé d'implémenter le tri par fusion en Python avec le moins de lignes possible
J'ai essayé d'implémenter Cifar10 avec la bibliothèque SONY Deep Learning NNabla [Nippon Hurray]
J'ai essayé de déboguer.
J'ai essayé d'entraîner la fonction péché avec chainer
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
J'ai essayé de mettre en œuvre la gestion des processus statistiques multivariés (MSPC)
Je voulais aussi vérifier les indices de type avec numpy
J'ai essayé de lire et d'enregistrer automatiquement avec VOICEROID2 2
J'ai essayé de démarrer avec le script python de blender_Part 01
J'ai essayé de toucher un fichier CSV avec Python