Forschung über Binance Futures Multi-Währung Hedging Strategie Teil 4

Binance Futures Multi-Währungs-Hedging-Strategies jüngste Überprüfung und Minute-Level-K-Line-Backtest-Ergebnisse

Drei Forschungsberichte über die Multi-Währungs-Hedging-Strategie von Binance wurden veröffentlicht, hier ist der vierte.

Forschung zur Binance Futures Multi-Währungs-Hedging-Strategie Teil 1:https://www.fmz.com/digest-topic/5584

Forschung zur Binance Futures Multi-Währungs-Hedging-Strategie Teil 2:https://www.fmz.com/digest-topic/5588

Forschung zur Binance-Futures-Multi-Währungs-Hedging-Strategie Teil 3:https://www.fmz.com/digest-topic/5605

Dieser Artikel soll die tatsächliche Marktlage der letzten Woche überprüfen und die Gewinne und Verluste zusammenfassen. Seit dem Durchsuchen der Binance Futures Minute K-Liniendaten der letzten zwei Monate können die ursprünglichen 1h K-Linien-Backtest-Ergebnisse aktualisiert werden, was die Bedeutung einiger Parameter-Einstellungen besser erklären kann.

# 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']

Daten der Zeile K auf der Ebene der Minuten

Die Daten vom 21. Februar bis zum 15. April um zwei Uhr nachmittags, insgesamt 77160 * 24, was unsere Backtest-Geschwindigkeit stark reduziert hat, die Backtest-Engine ist nicht effizient genug, Sie können sie selbst optimieren.

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']]

Überprüfung der letzten Woche

Der Strategie-Code wurde am 10. April in der WeChat-Gruppe veröffentlicht. Zu Beginn führte eine Gruppe von Leuten die Strategie 2 ((kurz überstieg und lang überstieg). In den ersten drei Tagen war die Rendite sehr gut, und der Rückschlag war sehr niedrig. In den folgenden Tagen vergrößerten einige Trader den Hebel, einige benutzten sogar den gesamten Betrag ihrer Gelder zum Betreiben, und die Gewinne erreichten 10% an einem Tag. Strategy Square veröffentlichte auch viele reale Marktstrategien, viele Leute begannen mit den konservativen empfohlenen Parametern unzufrieden zu sein und haben das Transaktionsvolumen verstärkt. Nach dem 13. April begann der Gewinn aufgrund des unabhängigen Trends von BNB zurückzugehen und seitwärts zu fallen. Wenn man sich den 3%-Default-Trade_value ansieht, ging er wahrscheinlich um 1%. Allerdings verlieren viele Trader und verdienen aufgrund der erweiterten Werte viel weniger. Diese Welle der Rückschlag war rechtzeitig, etwas beruhigend.

Der Wert des Nettowertes ist seit 4.13 auf den Höchststand des Nettowertes angestiegen und befindet sich in der Phase des Rückgangs und seitdem seitens der Seiten.

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);

Strategie 1, die Short-Altcoin-Strategie erzielt positive Renditen

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);

Strategie 2 Kauf von langem Überfall und Verkauf von kurzem Überstieg Gewinnanalyse

Die Ausdrucke der Endrechnungsinformationen zeigt, dass die meisten Währungen Gewinne erzielt haben und die BNB die meisten Verluste erlitten hat.

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);

Wenn BNB und ATOM entfernt werden, ist das Ergebnis besser, aber die Strategie befindet sich in letzter Zeit noch in der Retrace-Phase.

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);

In den letzten zwei Tagen ist es beliebt geworden, Mainstream-Währungsstrategien zu betreiben. Lassen Sie uns diese Strategie testen. Aufgrund der Abnahme der Währungsvielfalt wurde der Trade_value für den Vergleich angemessen um das Vierfache erhöht und die Ergebnisse liefen gut, insbesondere da der jüngste Rückschritt klein war.

Es sollte beachtet werden, dass nur die Mainstream-Währung im längeren Zeit-Backtest nicht so gut ist wie die volle Währung, und es gibt mehr 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 der Bearbeitungsgebühren und der Strategieparameter

Da in den ersten Berichten die Stunden-Level-K-Linie verwendet wurde und die tatsächlichen Parameter sich sehr von den realen Marktsituationen unterscheiden, können Sie nun mit der Minuten-Level-K-Linie sehen, wie Sie einige Parameter festlegen.

• Alpha = 0.03 Der Alpha-Parameter des exponentiellen gleitenden Durchschnitts. Je größer die Einstellung, desto empfindlicher ist die Benchmark-Preisverfolgung und desto weniger Transaktionen. Die endgültige Holding-Position wird ebenfalls niedriger sein, was den Hebelwert reduziert, aber auch die Rendite und die maximalen Retracements reduziert.

• Update_base_price_time_interval = 30 * 60 Wie oft der Basispreis in Sekunden aktualisiert wird, bezogen auf den Alpha-Parameter, je kleiner die Alpha-Einstellung, desto kleiner kann das Intervall festgelegt werden

• Trade_value: Jeder 1% des Altcoin-Preises (in BTC-Dimensionen) weicht vom Index-Holding-Wert ab, der nach den gesamten investierten Mitteln und der Risikopräferenz bestimmt werden muss. Es wird empfohlen, 3-10% der gesamten Mittel festzulegen. Sie können die Höhe des Hebels durch den Backtest der Forschungsumgebung betrachten. Trade_value kann kleiner als Adjust_value sein, z. B. die Hälfte von Adjust_value, was dem Holding-Wert von 2% aus dem Index entspricht.

• Adjust_value: Der Vertragswert (USDT-Bewertung) passt den Abweichungswert an. Wenn der Index von * Trade_value-current position> Adjust_value abweicht, d. h. die Differenz zwischen der Zielposition und der aktuellen Position diesen Wert übersteigt, wird der Handel gestartet. Zu große Anpassungen sind langsam, zu kleine Transaktionen sind häufig und können nicht kleiner als 10 sein, andernfalls wird der Mindesttransaktionswert nicht erreicht, es wird empfohlen, ihn auf mehr als 40% des Trade_value zu setzen.

Es ist unnötig zu sagen, dass Trade_value direkt mit unseren Gewinnen und Risiken zusammenhängt.

Da Alpha diesmal höhere Frequenzdaten hat, ist es offensichtlich vernünftiger, sie alle 1 Minute zu aktualisieren.

Adjust_value hat immer mehr als 40% des Trade_value empfohlen. Die ursprüngliche 1h K-Linie-Einstellung hat wenig Wirkung. Einige Leute wollen sie sehr niedrig anpassen, damit sie näher an der Zielposition sein kann. Hier werden wir analysieren, warum dies nicht getan werden sollte.

Zunächst analysieren Sie das Problem der Bearbeitung von Gebühren

Es kann gesehen werden, dass unter der Standardrate von 0,00075 die Handlinggebühr 293 und der Gewinn 270 beträgt, was ein sehr hoher Anteil ist.

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);

Das Ergebnis ist eine gerade Linie nach oben, BNB bringt nur ein wenig Wendungen, der niedrigere Adjust_value fängt jede Schwankung ein.

Was ist, wenn der Adjustment_value klein ist, wenn es eine geringe Handlinggebühr gibt?

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);

Es ist leicht zu verstehen, wenn man darüber nachdenkt, dass häufige Anpassungen innerhalb eines kleinen Spreads nur die Handling-Gebühr verlieren.

Insgesamt gilt: Je niedriger die Gebühren, desto kleiner der Adjust_value, desto häufiger die Transaktion und desto höher der Gewinn.

Probleme mit den Alpha-Einstellungen

Da es eine Minutenlinie gibt, wird der Benchmarkpreis einmal pro Minute aktualisiert, hier testen wir einfach zurück, um die Größe von Alpha zu bestimmen.

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

Backtestergebnisse der Minutenlinie in den letzten zwei Monaten

Schließlich schauen Sie sich die Ergebnisse eines langen Backtests an. Gerade jetzt steigt der eine nach dem anderen und das heutige Vermögen liegt auf einem neuen Tief. Lassen Sie uns Ihnen folgende Zuversicht geben. Da die Frequenz der Minutenlinie höher ist, wird sie innerhalb einer Stunde Positionen öffnen und schließen, so dass der Gewinn viel höher sein wird.

Ein weiterer Punkt ist, daß wir immer einen festen Trade-Value verwendet haben, was die Verwendung von Mitteln in der späteren Periode unzureichend macht, und die tatsächliche Rendite kann immer noch stark steigen.

Wo stehen wir in der zweimonatigen Backtest-Periode?

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);