Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 4
Auteur:La bonté, Créé: 2020-05-14 15:18:56, Mis à jour: 2023-11-04 19:51:33
La récente revue de la stratégie de couverture multi-monnaie des contrats à terme de Binance et les résultats du backtest de la ligne K au niveau des minutes
Trois rapports de recherche sur la stratégie de couverture multi-monnaie de Binance ont été publiés, voici le quatrième.
Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 1:https://www.fmz.com/digest-topic/5584
Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 2:https://www.fmz.com/digest-topic/5588
Recherche sur la stratégie de couverture multi-monnaie des contrats à terme Binance Partie 3:https://www.fmz.com/digest-topic/5605
Cet article est destiné à passer en revue la situation réelle du marché de la dernière semaine et à résumer les gains et les pertes.
# Libraries to import
import pandas as pd
import requests
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
%matplotlib inline
symbols = ['BTC','ETH', 'BCH', 'XRP', 'EOS', 'LTC', 'TRX', 'ETC', 'LINK', 'XLM', 'ADA', 'XMR', 'DASH', 'ZEC', 'XTZ', 'BNB', 'ATOM', 'ONT', 'IOTA', 'BAT', 'VET', 'NEO', 'QTUM', 'IOST']
Données de ligne K au niveau des minutes
Les données du 21 février au 15 avril à deux heures de l'après-midi, un total de 77160 * 24, ce qui a considérablement réduit notre vitesse de backtest, le moteur de backtest n'est pas assez efficace, vous pouvez l'optimiser vous-même.
price_usdt = pd.read_csv('https://www.fmz.com/upload/asset/2b1fa7ab641385067ad.csv',index_col = 0)
price_usdt.shape
(77160, 24)
price_usdt.index = pd.to_datetime(price_usdt.index,unit='ms')
price_usdt_norm = price_usdt/price_usdt.fillna(method='bfill').iloc[0,]
price_usdt_btc = price_usdt.divide(price_usdt['BTC'],axis=0)
price_usdt_btc_norm = price_usdt_btc/price_usdt_btc.fillna(method='bfill').iloc[0,]
class Exchange:
def __init__(self, trade_symbols, leverage=20, commission=0.00005, initial_balance=10000, log=False):
self.initial_balance = initial_balance # Initial asset
self.commission = commission
self.leverage = leverage
self.trade_symbols = trade_symbols
self.date = ''
self.log = log
self.df = pd.DataFrame(columns=['margin','total','leverage','realised_profit','unrealised_profit'])
self.account = {'USDT':{'realised_profit':0, 'margin':0, 'unrealised_profit':0, 'total':initial_balance, 'leverage':0, 'fee':0}}
for symbol in trade_symbols:
self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0, 'margin':0, 'unrealised_profit':0,'fee':0}
def Trade(self, symbol, direction, price, amount, msg=''):
if self.date and self.log:
print('%-20s%-5s%-5s%-10.8s%-8.6s %s'%(str(self.date), symbol, 'buy' if direction == 1 else 'sell', price, amount, msg))
cover_amount = 0 if direction*self.account[symbol]['amount'] >=0 else min(abs(self.account[symbol]['amount']), amount)
open_amount = amount - cover_amount
self.account['USDT']['realised_profit'] -= price*amount*self.commission # Minus handling fee
self.account['USDT']['fee'] += price*amount*self.commission
self.account[symbol]['fee'] += price*amount*self.commission
if cover_amount > 0: # close position first
self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount # profit
self.account['USDT']['margin'] -= cover_amount*self.account[symbol]['hold_price']/self.leverage # Free margin
self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
self.account[symbol]['amount'] -= -direction*cover_amount
self.account[symbol]['margin'] -= cover_amount*self.account[symbol]['hold_price']/self.leverage
self.account[symbol]['hold_price'] = 0 if self.account[symbol]['amount'] == 0 else self.account[symbol]['hold_price']
if open_amount > 0:
total_cost = self.account[symbol]['hold_price']*direction*self.account[symbol]['amount'] + price*open_amount
total_amount = direction*self.account[symbol]['amount']+open_amount
self.account['USDT']['margin'] += open_amount*price/self.leverage
self.account[symbol]['hold_price'] = total_cost/total_amount
self.account[symbol]['amount'] += direction*open_amount
self.account[symbol]['margin'] += open_amount*price/self.leverage
self.account[symbol]['unrealised_profit'] = (price - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
self.account[symbol]['price'] = price
self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*price
return True
def Buy(self, symbol, price, amount, msg=''):
self.Trade(symbol, 1, price, amount, msg)
def Sell(self, symbol, price, amount, msg=''):
self.Trade(symbol, -1, price, amount, msg)
def Update(self, date, close_price): # Update assets
self.date = date
self.close = close_price
self.account['USDT']['unrealised_profit'] = 0
for symbol in self.trade_symbols:
if np.isnan(close_price[symbol]):
continue
self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
self.account[symbol]['price'] = close_price[symbol]
self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*close_price[symbol]
self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)
self.account['USDT']['leverage'] = round(self.account['USDT']['margin']/self.account['USDT']['total'],4)*self.leverage
self.df.loc[self.date] = [self.account['USDT']['margin'],self.account['USDT']['total'],self.account['USDT']['leverage'],self.account['USDT']['realised_profit'],self.account['USDT']['unrealised_profit']]
Révision de la semaine dernière
Le code de la stratégie a été publié dans le groupe WeChat le 10 avril. Au début, un groupe de personnes a exécuté la stratégie 2 ((short over-rise et long over-fall). Au cours des trois premiers jours, le rendement était très bon et le retracement était très faible. Dans les jours suivants, certains traders ont amplifié l'effet de levier, certains utilisent même tout le montant de leurs fonds pour opérer, et les gains ont atteint 10% en une journée. Strategy Square a également publié de nombreuses stratégies de marché réelles, de nombreuses personnes ont commencé à être insatisfaites des paramètres recommandés conservateurs, et ont amplifié le volume de transaction. Après le 13 avril, en raison de la tendance indépendante de BNB
Nous allons jeter un coup d'œil au backtest complet de la stratégie 2. Ici, comme il s'agit d'une mise à jour de niveau minute, le paramètre Alpha doit être ajusté. D'un point de vue du marché réel, la tendance de la courbe est cohérente, ce qui indique que notre backtest peut être utilisé comme une référence solide. La valeur nette a atteint le pic de la valeur nette à partir de 4,13 et est en phase de retracement et latérale.
Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 0.5*trade_value:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < -0.5*trade_value:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2a = e
(stragey_2a.df['total']/stragey_2d.initial_balance).plot(figsize=(17,6),grid = True);
Stratégie 1, la stratégie des altcoins à court terme réalise des rendements positifs
trade_symbols = list(set(symbols)-set(['LINK','BTC','XTZ','BCH', 'ETH'])) # Selling short currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.00075,log=False)
trade_value = 2000
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
empty_value = 0
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
if e.account[symbol]['value'] - trade_value < -120 :
e.Sell(symbol, price, round((trade_value-e.account[symbol]['value'])/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if e.account[symbol]['value'] - trade_value > 120 :
e.Buy(symbol, price, round((e.account[symbol]['value']-trade_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
empty_value += e.account[symbol]['value']
price = row[1]['BTC']
if e.account['BTC']['value'] - empty_value < -120:
e.Buy('BTC', price, round((empty_value-e.account['BTC']['value'])/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
if e.account['BTC']['value'] - empty_value > 120:
e.Sell('BTC', price, round((e.account['BTC']['value']-empty_value)/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_1 = e
(stragey_1.df['total']/stragey_1.initial_balance).plot(figsize=(17,6),grid = True);
Stratégie 2 Achat de plus-value et vente de plus-value analyse des bénéfices
L'impression des informations du compte final montre que la plupart des devises ont généré des profits et que la BNB a subi le plus de pertes.
pd.DataFrame(stragey_2a.account).T.apply(lambda x:round(x,3)).sort_values(by='realised_profit')
# BNB deviation
(price_usdt_btc_norm2.iloc[-7500:].BNB-price_usdt_btc_norm_mean[-7500:]).plot(figsize=(17,6),grid = True);
#price_usdt_btc_norm_mean[-7500:].plot(figsize=(17,6),grid = True);
Si BNB et ATOM sont supprimés, le résultat est meilleur, mais la stratégie sera encore dans la phase de retracement récemment.
Alpha = 0.001
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols)-set(['BNB','ATOM']))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 0.5*trade_value:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < -0.5*trade_value:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2b = e
(stragey_2b.df['total']/stragey_2b.initial_balance).plot(figsize=(17,6),grid = True);
Au cours des deux derniers jours, il est devenu populaire d'exécuter des stratégies de devises traditionnelles.
Il convient de noter que seule la monnaie courante n'est pas aussi bonne que la monnaie complète dans le backtest de temps plus long, et il y a plus de retracements.
Alpha = 0.001
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = ['ETH','LTC','EOS','XRP','BCH']
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 1200
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 0.5*trade_value:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < -0.5*trade_value:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2c = e
(stragey_2c.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);
Analyse des paramètres des frais de traitement et de la stratégie
Puisque les premiers rapports utilisaient la ligne k de niveau d'heure, et que les paramètres réels sont très différents des situations réelles du marché, maintenant avec la ligne k de niveau de minutes, vous pouvez voir comment définir certains paramètres.
-
Alpha = 0,03 Le paramètre Alpha de la moyenne mobile exponentielle. Plus le réglage est grand, plus le suivi des prix de référence est sensible et moins les transactions sont nombreuses. La position finale de détention sera également plus faible, ce qui réduit l'effet de levier, mais réduira également le rendement et les retracements maximaux.
-
Update_base_price_time_interval = 30 * 60 Combien de fois mettre à jour le prix de base, en secondes, en relation avec le paramètre Alpha, plus le réglage Alpha est petit, plus l'intervalle peut être réglé
-
Trade_value: Chaque 1% du prix de l'altcoin (dénominé en BTC) dévie de la valeur de détention de l'indice, qui doit être déterminée en fonction des fonds totaux investis et de la préférence de risque. Il est recommandé de définir 3-10% des fonds totaux. Vous pouvez examiner la taille du levier à travers le backtest de l'environnement de recherche. La valeur de la transaction peut être inférieure à la valeur d'ajustement, telle que la moitié de la valeur d'ajustement, ce qui équivaut à la valeur de détention de 2% de l'indice.
-
Adjust_value: La valeur du contrat (évaluation USDT) ajuste la valeur de l'écart. Lorsque l'indice s'écarte de * Trade_value-position actuelle> Adjust_value, c'est-à-dire que la différence entre la position cible et la position actuelle dépasse cette valeur, la négociation démarre. Les ajustements trop importants sont lents, les transactions trop petites sont fréquentes et ne peuvent pas être inférieures à 10, sinon la transaction minimale ne sera pas atteinte, il est recommandé de la fixer à plus de 40% de la valeur Trade_value.
Il est inutile de dire que la valeur du commerce est directement liée à nos gains et à nos risques.
Comme Alpha a des données de fréquence plus élevées cette fois, il est évidemment plus raisonnable de les mettre à jour toutes les 1 minute.
Le paramètre de la ligne 1h K a peu d'effet. Certaines personnes veulent l'ajuster très bas, afin qu'il puisse être plus proche de la position cible.
Tout d'abord, analysez le problème des frais.
On peut voir que sous le taux par défaut de 0,00075, les frais de manutention sont de 293 et le profit est de 270, ce qui est une proportion très élevée.
stragey_2a.account['USDT']
{'fee': 293.85972778530453,
'leverage': 0.45999999999999996,
'margin': 236.23559736312995,
'realised_profit': 281.77464608744435,
'total': 10271.146238,
'unrealised_profit': -10.628408369648495}
Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 10:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < 10:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2d = e
(stragey_2d.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);
Le résultat est une ligne droite vers le haut, BNB apporte seulement quelques rebondissements, la valeur inférieure de l'ajustement capte toutes les fluctuations.
Que faire si la valeur d'ajustement est faible s'il y a un petit montant de frais de manutention?
Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 10:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < 10:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2e = e
(stragey_2e.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);
En conséquence, il est également sorti d'une courbe descendante linéaire.
Dans l'ensemble, plus le niveau des frais est bas, plus la valeur d'ajustement peut être réduite, plus la transaction est fréquente et plus le profit est élevé.
Problèmes avec les paramètres Alpha
Puisqu'il y a une ligne minute, le prix de référence sera mis à jour une fois par minute, ici, nous effectuons simplement un backtest pour déterminer la taille de l'alpha.
for Alpha in [0.0001, 0.0003, 0.0006, 0.001, 0.0015, 0.002, 0.004, 0.01, 0.02]:
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() #Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 0.5*trade_value:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < -0.5*trade_value:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
print(Alpha, e.account['USDT']['unrealised_profit']+e.account['USDT']['realised_profit'])
0.0001 -77.80281760941007
0.0003 179.38803796199724
0.0006 218.12579924541367
0.001 271.1462377177959
0.0015 250.0014065973528
0.002 207.38692166891275
0.004 129.08021828803027
0.01 65.12410041648158
0.02 58.62356792410955
Résultats des tests de retour de la ligne minute au cours des deux derniers mois
Enfin, regardez les résultats d'un backtest de longue date. Juste maintenant, l'un après l'autre augmente, et la valeur nette d'aujourd'hui est à un nouveau plus bas. Laissez-nous vous donner la confiance suivante. Parce que la fréquence de la ligne de minute est plus élevée, elle ouvrira et fermera des positions dans l'heure, donc le profit sera beaucoup plus élevé.
Un autre point, nous avons toujours utilisé une valeur commerciale fixe, ce qui rend l'utilisation des fonds dans la période ultérieure insuffisante, et le taux de rendement réel peut encore augmenter beaucoup.
Où en sommes-nous dans la période de dossiers de deux mois?
Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
e.Update(row[0], row[1])
for symbol in trade_symbols:
price = row[1][symbol]
if np.isnan(price):
continue
diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
aim_value = -trade_value*round(diff/0.01,1)
now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
if aim_value - now_value > 0.5*trade_value:
e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
if aim_value - now_value < -0.5*trade_value:
e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2f = e
(stragey_2f.df['total']/stragey_2e.initial_balance).plot(figsize=(17,6),grid = True);
(stragey_2f.df['leverage']/stragey_2e.initial_balance).plot(figsize=(17,6),grid = True);
- Introduction à l'arbitrage au retard de plomb dans les crypto-monnaies (2)
- Introduction à la suite de Lead-Lag dans les monnaies numériques (2)
- Discussion sur la réception de signaux externes de la plateforme FMZ: une solution complète pour la réception de signaux avec un service Http intégré dans la stratégie
- Exploration de la réception de signaux externes sur la plateforme FMZ: stratégie intégrée pour la réception de signaux sur le service HTTP
- Introduction à l'arbitrage au retard de plomb dans les crypto-monnaies (1)
- Introduction à la suite de Lead-Lag dans les monnaies numériques (1)
- Discussion sur la réception de signaux externes de la plateforme FMZ: API étendue VS stratégie intégrée au service HTTP
- Débat sur la réception de signaux externes sur la plateforme FMZ: API étendue contre stratégie de service HTTP intégré
- Discussion sur la méthode de test de stratégie basée sur le générateur de tickers aléatoires
- Une méthode de test stratégique basée sur un générateur de marché aléatoire
- Nouvelle fonctionnalité de FMZ Quant: Utilisez la fonction _Serve pour créer facilement des services HTTP
- Stratégie R-Breaker des contrats à terme sur matières premières
- Un peu de réflexion sur la logique des échanges de devises numériques
- Vous apprendre à mettre en œuvre un collecteur de cotations de marché
- Stratégie de moyenne mobile des contrats à terme sur matières premières
- Le collecteur de cotations de marché est à nouveau mis à niveau.
- Réaménagement du collecteur de données - support des importations de fichiers au format CSV pour fournir des sources de données personnalisées
- Stratégie de négociation à haute fréquence sur les contrats à terme sur matières premières écrite en C++
- Larry Connors RSI2 Stratégie d'inversion moyenne
- Les ouvriers vous apprennent à utiliser l'API de couplage JS pour étendre FMZ
- Basé sur l'utilisation d'un nouvel indice de résistance relative dans les stratégies intraday
- Larry Connors Larry Connors RSI2 stratégie de régression moyenne
- Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 3
- Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 2
- Recherche sur la stratégie de couverture multi-monnaie des contrats à terme de Binance Partie 1
- Le manuel vous apprend à mettre à niveau la fonctionnalité de récupération des sources de données personnalisées pour le collecteur de transactions
- Système de négociation de ligne de crocodile version Python
- L'API de l'extension de la plate-forme de négociation quantitative utilisée par les inventeurs pour réaliser des transactions de signaux d'alarme TradingView (recommandé)
- Version JavaScript de la stratégie SuperTrend
- SuperTrend V.1 - Système de ligne de tendance supérieure
- La stratégie de SuperTrend de la version JavaScript