Nous avons créé une fonctionnalité de retouche de transaction en ligne avec FMZ.

Retour à l'origine

J'ai essayé de trouver un outil qui réponde en temps réel, et pendant un certain temps, j'ai pensé que vnpy était trop compliqué pour changer d'interface. Il y a aussi un article dans le guide de FMZ. Nous avons trouvé que c'était une fonctionnalité que nous voulions, nous l'avons sorti et nous l'avons utilisé pendant six mois pour discuter avec vous. En fait, j'ai trouvé que l'article de fmz était trop petit pour être utile dans un guide pour débutants, mais j'ai compris en posant une question.

La première est que les utilisateurs peuvent choisir leur heure de début et leur heure de fin.

Il y a des paramètres à régler:

Je ne sais pas si une fonction peut être initialisée.

self.grid_setting = {
          "min_price": min_price,
          "max_price": max_price,
          "grid_diff": grid_diff,
          "re_diff": grid_diff,
          "total_amount_B": total_amount_B
      }

Paramètres de configuration de la grille: prix minimum, prix maximum, intervalle de distribution de la grille et intervalle de réapposition.

Les paramètres ci-dessus ont été soumis par les utilisateurs.

La fonction principale de bus est

    def bus(self):
      params = gen_params(self.begin, self.end, self.currency, self.balance, self.stocks)
      task = VCtx(params)
      done = self.train()
      ret = task.Join(True)
      benefit_cal = self.cal_benefit(ret,done)
      result = {}
      result['done'] = done
      result['ret'] = benefit_cal
      return result

• Obtenir la configuration de réinitialisation de fmz avec la fonction gen_params que vous venez de créer
• Fonction d'entraînement à la course
• Calcul des rendements et affichage des enregistrements de transactions selon la structure de données retournée par fmz

L'appel de task.Join () met fin à la tâche de retouche et renvoie des données de valeur nette.

Par la documentation, je devine ce que signifie le résultat de la stratégie.

Le code est calculé en ajoutant les données de rendement retournées par fmz

  def cal_benefit(self,ret,done):
      #计算相隔多少天
      day_begin =  datetime.datetime.strptime(self.begin, '%Y-%m-%d %H:%M:%S')
      day_end =  datetime.datetime.strptime(self.end, '%Y-%m-%d %H:%M:%S')
      days = (day_end - day_begin).days
      begin = ret.iloc[0].net
      end = ret.iloc[-1].net
      fee = ret.iloc[-1].fee
      #计算一共多少次套利
      df = pd.DataFrame(done)
      #如果没有成交记录
      if len(done) == 0:
          benefit_cal = {}
          benefit_cal['benefit'] = 0
          benefit_cal['count'] = 0
          benefit_cal['fee'] = 0
          benefit_cal['benefit_p'] = 0
          return benefit_cal

      buy_count = len(df[df['type'] == 'buy'])
      sell_count = len(df[df['type'] == 'sell'])
      count = min(buy_count , sell_count)
      benefit = count * self.grid_diff * float(done[0]['amount'])
      benefit_cal = {}
      benefit_cal['benefit']= benefit
      benefit_cal['count']= count
      benefit_cal['fee']= fee
      print(benefit_cal)
      per = benefit / self.total_amount_B * 360 / days
      print(per)
      benefit_cal['benefit_p']= round( per , 4)
      return benefit_cal

C'est vrai. Je me sens un peu désorienté, mais je vais d'abord vous parler de nos idées de réseau:

Le projet est basé sur l'idée d'une vérification de l'annuaire.

• Tout d'abord, initialez la grille en fonction des paramètres de l'utilisateur.
• Première annonce
• Vérifiez la transaction en temps opportun et réécrivez la transaction en fonction de la demande.

          while True:
              Sleep(1000 * 60 * 5)
              if 'refreash_data_finish!' != mid.refreash_data():
                  continue
              # 初始化网格
              if not init_flag:
                  cur_price = mid.ticker['Last']
                  grid_list = grid.cal_grid_list(cur_price)
                  init_flag = True

              # 开始挂单
              if not place_flag:
                  grid.place_orders()
                  place_flag = True

              # 开始检查订单状态及时挂单
              grid.check_order_update()
              done = grid.done

C'est peut-être ça, peut-être un peu bizarre au premier coup d'œil.

Cette fois, je voulais partager principalement pour exprimer que la vitesse de répétition de fmz en 14 jours peut essentiellement répondre aux temps d'attente des utilisateurs sur le front-end, plus il est long, un peu plus lent, est un bon outil de répétition quantitative comme interface, bravo!

Oui, cette fois encore, nous sommes de retour pour promouvoir une vague de compétition de négociation, notre équipe de quantification éternelle a organisé une compétition de négociation, gratuite pour participer.