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

Schriftsteller:Gutes, Erstellt: 2020-05-09 11:14:50, Aktualisiert: 2023-11-04 19:49:01

Klicken Sie auf die Suche-Taste auf der Dashboard-Seite und klicken Sie dann auf den Pfeil, um einzugeben. Öffnen Sie die hochgeladene.pynb-Suffixdatei und drücken Sie Shift + Enter, um Zeile für Zeile auszuführen. Es gibt grundlegende Tutorials in der Benutzerhilfe der Forschungsumgebung.

Strategische Gründe

Binance hat viele Altcoins vor Ort gelistet. Obwohl die kurzfristigen Schwankungen unsicher sind, werden Sie feststellen, wenn Sie die tägliche Linie für eine lange Zeit betrachten, dass sie im Grunde um mehr als 90% gefallen sind, und einige haben sogar nur Bruchteile des höchsten Preisanteils. Es gibt jedoch keine universelle Leerverkaufsmethode für den Spot, und es gibt keine spezielle Empfehlung, außer nicht das Altcoin zu berühren. In den letzten zwei Monaten hat Binance Futures mehr als 20 ewige Verträge gestartet, von denen die meisten Mainstream-Währungen sind, und einige sind unbekannt. Dies gibt uns die Mittel, diese Altcoin-Kombinationen zu shorten. Mit dem Korrelationskoeffizienten zwischen Altcoins und BTC wird eine effektive Analysemethode sein, zwei Strategien können entworfen werden.

Grundsätze der Strategie

Die erste Strategie: Kurzverkauf des ausgewählten Korbs von Altcoins in einem dezentralen Äquivalent und gleichzeitig Kauf der gleichen Menge an Position BTC, um Risiken und Volatilität zu reduzieren.

Die zweite Strategie: Shorting von Währungen mit einem Preis, der höher als der Altcoin-Bitcoin-Preisindex ist, und Longing mit Währungen, die niedriger als der Index sind, je größer die Abweichung, desto größer die Position.

# Libraries to import
import pandas as pd
import requests
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
%matplotlib inline

Auswahl der gewünschten Währung

Die derzeit gelisteten Währungen des Binance-Perpetual Contracts, die über die API-Schnittstelle erhältlich sind, sind insgesamt 23 (ohne BTC).

#Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
#symbols = [symbol_info['baseAsset'] for symbol_info in Info.json()['symbols']]
symbols = ['ETH', 'BCH', 'XRP', 'EOS', 'LTC', 'TRX', 'ETC', 'LINK', 'XLM', 'ADA', 'XMR', 'DASH', 'ZEC', 'XTZ', 'BNB', 'ATOM', 'ONT', 'IOTA', 'BAT', 'VET', 'NEO', 'QTUM', 'IOST']

Ich habe die Daten im Voraus heruntergeladen und auf dem Forum gepostet, das direkt in der Forschungsumgebung zitiert werden kann.

price_btc = pd.read_csv('https://www.fmz.com/upload/asset/1ef1af8ec28a75a2dcb.csv', index_col = 0)
price_btc.index = pd.to_datetime(price_btc.index,unit='ms') #Index date

price_btc.tail()

Ergebnisse:

5 Zeilen × 23 Spalten

Es ist jedoch nicht möglich, die Preisentwicklung der anderen Währungen zu ermitteln, da die Preise der anderen Währungen im Wesentlichen die gleichen sind und eine Abwärtsentwicklung zeigen.

price_btc_norm = price_btc/price_btc.fillna(method='bfill').iloc[0,]
price_btc_norm.plot(figsize=(16,6),grid = True,legend=False);

Durch das Sortieren der letzten Kursänderungen können Sie mehrere Münzen finden, die sich offensichtlich unterscheiden, nämlich LINK, XTZ, BCH, ETH. Erklären Sie, dass sie oft ihren eigenen Trend betreiben können und dass ein Shorting von ihnen ein höheres Risiko birgt und aus der Strategie ausgeschlossen werden muss.

Zeichnen Sie eine Wärmekarte des Korrelationskoeffizienten der verbleibenden Währungen und stellen Sie fest, dass der Trend von ETC und ATOM ebenfalls relativ speziell ist und ausgeschlossen werden kann.

price_btc_norm.iloc[-1,].sort_values()[-5:]

Ergebnisse:

ETH     0.600417
ETC     0.661616
BCH     1.141961
XTZ     2.512195
LINK    2.764495
Name: 2020-03-25 00:00:00, dtype: float64

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies

plt.subplots(figsize=(12, 12)) # Set the screen size
sns.heatmap(price_btc[trade_symbols].corr(), annot=True, vmax=1, square=True, cmap="Blues");

Die letzte verbleibende Währung fiel um durchschnittlich 66% pro Jahr, offensichtlich gibt es viel Raum für einen Shorting. Wenn man den Trend dieser Münzen in den Altcoin-Preisindex zusammenfasst, wurde festgestellt, dass er im Grunde genommen den ganzen Weg fiel, in der zweiten Hälfte des letzten Jahres stabiler war und in diesem Jahr den ganzen Weg fiel. Diese Studie untersuchte LINK, XTZ, BCH, ETH, ETC, ATOM, BNB, EOS, LTC nicht an der Kurzzeit der ersten Strategie teilgenommen hat, spezifische Details können selbst getestet werden.

Es sollte beachtet werden, dass der aktuelle Altcoin-Index am Tiefpunkt des vergangenen Jahres liegt. Vielleicht ist es keine kurze Gelegenheit, sondern eine lange Kaufmöglichkeit. Sie müssen es selbst entscheiden.

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # You can set the remaining currencies, which you want to subtract.
1-price_btc_norm[trade_symbols].iloc[-1,].mean()

Ergebnisse:

0.6714306758250285

price_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

Binance Nachhaltigkeitsdaten

In ähnlicher Weise wurden die Daten zur Nachhaltigkeit von Binance zusammengestellt, Sie können sie auch direkt in Ihrem Notizbuch zitieren, die Daten sind die 1h-Markt-K-Linie vom 28. Januar bis 31. März 2020, da die meisten Binance-Perpetual-Kontrakte nur zwei Monate lang mitgeteilt wurden, so dass die Daten für Backtests ausreichen.

price_usdt = pd.read_csv('https://www.fmz.com/upload/asset/20227de6c1d10cb9dd1.csv ', index_col = 0)
price_usdt.index = pd.to_datetime(price_usdt.index)

price_usdt.tail()

Ergebnisse:

Der Marktanteil der Banken in den letzten Jahren hat sich in den letzten Jahren deutlich verringert, und die Entwicklung der Marktanteile in den vergangenen Jahren hat sich in den letzten Jahren deutlich verändert.

price_usdt_norm = price_usdt/price_usdt.fillna(method='bfill').iloc[0,]
price_usdt_norm.plot(figsize=(16,6),grid = True,legend=False);

Zeichnen Sie den Indexpreis der Münze, die wir gegen Bitcoin verkaufen wollen, das Strategieprinzip ist, diese Kurve zu verkürzen, und die Rendite ist im Grunde die Umkehrung dieser Kurve.

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,]
price_usdt_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True);
#price_usdt_btc_norm.mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

Motortest im Rücklauf

Da der lokale FMZ-Backtest keine Daten für alle Währungen hat und keinen Multi-Währungs-Backtest unterstützt, ist es notwendig, eine neue Backtest-Engine neu zu implementieren. Also schrieb ich eine neue Backtest-Engine, es ist relativ einfach, aber im Grunde genug. Unter Berücksichtigung der Transaktionsgebühr, aber im Grunde ignoriert die Kapitalquote, nicht die Situation der Aufrechterhaltung der Margin-Kapital berücksichtigt. Das Gesamtkapital, besetzte Marge und Hebelwirkung wurden aufgezeichnet. Da diese Strategie das Attribut hat, dass lange Position gleich kurzer Position ist, so dass die Auswirkungen der Kapitalraten nicht signifikant sind.

Der Backtest berücksichtigt nicht die Preisrutschsituation, Sie können die Simulation der Transaktionsgebühren selbst erhöhen, wenn Sie die niedrige Transaktionsgebühr von Binance Maker berücksichtigen, selbst der Preisunterschied auf dem unpopulären Devisenmarkt ist sehr klein, Sie können die Eisbergprovisionsmethode auf dem realen Markt verwenden, wenn Sie eine Bestellung aufgeben, sollte die Wirkung nicht signifikant sein.

Bei der Erstellung eines Tauschobjekts müssen Sie die zu handelende Währung angeben. Kaufen ist lang und Verkaufen ist kurz. Aufgrund der ständigen Vertragsbeschränkung werden bei Eröffnung der Position die langen und kurzen Positionen automatisch zusammen geschlossen. Bei Verkauf der kurzen Position und die Anzahl der Währungen sind negativ. Die Parameter sind wie folgt:

trade_symbols: Liste der zu handelnden Währungen
Hebelwirkung: Hebelwirkung, Effektmarge,
Provision: Transaktionsgebühr, Standard 0.00005
initial_balance: Anfangsvermögen, Bewertung in USDT
Log: Ob Transaktionsprotokolle ausgedruckt werden sollen

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}}
        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}
            
    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 transaction fee
        
        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 the 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']
            if self.date.hour in [0,8,16]:
                pass
                self.account['USDT']['realised_profit'] += -self.account[symbol]['amount']*close_price[symbol]*0.01/100
        
        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']]

# First test the backtest engine
e = Exchange(['BTC','XRP'],initial_balance=10000,commission=0,log=True)

e.Buy('BTC',100, 5)
e.Sell('XRP',10, 50)

e.Sell('BTC',105,e.account['BTC']['amount'])
e.Buy('XRP',9,-e.account['XRP']['amount'])

round(e.account['USDT']['realised_profit'],4)

75.0

Der erste Strategiecode

Strategie Logik:

Überprüfen Sie den Währungspreis, wenn nicht nan, können Sie handeln
Überprüfen Sie den Wert des Altcoin-Kontrakts. Wenn er unter dem Zielwert trade_value liegt, wird die entsprechende Differenz kurz verkauft, und wenn er größer ist, wird der entsprechende Betrag gekauft, um die Position zu schließen.
Fügen Sie den Short-Wert aller Altcoins hinzu und passen Sie die BTC-Position an, um sich dagegen abzusichern.

Die Position short trade_value bestimmt die Größe der Position.

# Need to hedge with BTC
trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].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  < -20 :
            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 > 20 :
            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 < -20:
        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 > 20:
        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

Der endgültige Gewinn jeder Währung ist wie folgt:

pd.DataFrame(stragey_1.account).T.apply(lambda x:round(x,3))

Die beiden nachstehenden Grafiken zeigen die Vermögenskurve und die eingesetzte Hebelwirkung.

Die gelbe Linie in der Nettovermögenskurve ist der Effekt der 1x Hebelwirkung, die den Altcoin-Index kurz macht. Es kann gesehen werden, dass die Strategie die Schwankung des Index im Wesentlichen verstärkt, was den Erwartungen entspricht. Die endgültige Zwei-Monats-Rendite beträgt 60%, der maximale Rückgriff beträgt 20% und die maximale Hebelwirkung beträgt etwa 8-mal. Meistens ist sie weniger als 6-mal. Es ist immer noch sicher. Am wichtigsten ist, dass die vollständige Absicherung die Strategie beim Sturz am 12. März wenig verlieren lässt.

Wenn der Leerverkaufspreis steigt und der Vertragswert steigt, wird die Position reduziert, während die Position beim Gewinn erhöht wird. Dies hält den Gesamtwert des Vertrages konstant, auch wenn die rasanten Rückgänge begrenzte Verluste haben.

Aber die Risiken wurden auch früher erwähnt, Altcoins sind sehr wahrscheinlich, ihren eigenen Trend zu laufen, und kann viel von unten steigen. Es hängt davon ab, wie Sie es verwenden. Wenn Sie optimistisch über die Altcoin sind und denken, dass es den Boden erreicht hat, können Sie in der Richtung handeln und kaufen lang diesen Index. Oder wenn Sie optimistisch über bestimmte Währungen sind, können Sie mit ihnen absichern.

(stragey_1.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
#(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

# Strategy leverage
stragey_1.df['leverage'].plot(figsize=(18,6),grid = True);

Darüber hinaus ist der Preis des Altcoins gegenüber dem USDT ebenfalls gefallen, der extreme Plan ist nicht abgesichert, direkt kurz verkauft, aber die Schwankung ist sehr groß und der Rückzug hoch

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].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  < -20 :
            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 > 20 :
            pass
            #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']
stragey_1b = e

(stragey_1b.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

Der zweite Strategiecode

Strategie Logik:

Überprüfen Sie, ob es einen Preis oder einen Preis zum Handel gibt
Überprüfen Sie die Abweichung des Währungskurses vom Index
Gehen Sie lang und kurz basierend auf der Abweichung Urteil, und beurteilen Sie die Position nach der Abweichung Größe
Berechnung nicht abgesicherter Positionen und Absicherung mit BTC

Sie können auch den Umrechnungsfaktor von diff/0.001 ändern

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,0)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 50:
            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 < -50:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 50:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -50:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2 = e

Die Rendite der zweiten Strategie ist viel besser als die erste Strategie. In den letzten zwei Monaten hat sie eine Rendite von 100%, hat aber immer noch einen Rückzug von 20%. In der vergangenen Woche ist die Rendite aufgrund der kleinen Marktschwankungen nicht offensichtlich. Der Gesamtertrag ist nicht viel. Diese Strategie lohnt sich zu versuchen. Je nach Abweichungsgrad wurden höchstens mehr als 7800 USDT-Positionen eröffnet.

Beachten Sie, dass, wenn eine Währung einen unabhängigen Trend verläuft, z. B. mehrfach im Verhältnis zum Index gestiegen ist, eine große Anzahl von Short-Positionen in der Währung angesammelt wird, und der gleiche starke Rückgang wird auch die Strategie zum Kauf lang machen, was die maximale Eröffnungsposition einschränken kann.

(stragey_2.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);

# Summary results by currency
pd.DataFrame(e.account).T.apply(lambda x:round(x,3))

e.df['leverage'].plot(figsize=(18,6),grid = True);

Wenn das Ergebnis der Nicht-Hedging wie folgt ist, ist der Unterschied eigentlich nicht viel, weil lange und kurze Positionen im Grunde ausgeglichen sind.

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.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'])
        empty_value += now_value
        if aim_value - now_value > 20:
            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 < -20:
            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_2.initial_balance).plot(figsize=(18,6),grid = True);
#(stragey_2.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True); # Can be stacked together

Wenn Sie sich auf die USDT-Preisregression beziehen, wird der Effekt viel schlimmer sein

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH']))+['BTC'] #Remaining currencies
price_usdt_norm_mean = price_usdt_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols+['BTC']:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_norm.loc[row[0],symbol] - price_usdt_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'])
        empty_value += now_value
        if aim_value - now_value > 20:
            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 < -20:
            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']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);
(stragey_2b.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);

Wenn Sie den maximalen Positionswert begrenzen, wird die Leistung schlechter sein

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) #Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.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'])
        empty_value += now_value
        if aim_value - now_value > 20 and abs(aim_value)<3000:
            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 < -20 and abs(aim_value)<3000:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 20:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -20:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2d = e

(stragey_2d.df['total']/stragey_2.initial_balance).plot(figsize=(17,6),grid = True);

Zusammenfassung und Risiko

Die erste Strategie nutzt die Tatsache aus, dass der Gesamtwert von Altcoins nicht so gut ist wie Bitcoin. Wenn Sie lange Bitcoins kaufen, möchten Sie sich möglicherweise lange an diese Strategie halten. Aufgrund der Long- und Short-Positionsäquivalenz haben Sie grundsätzlich keine Angst vor der Finanzierungsrate von 8h. Auf lange Sicht ist die Gewinnrate relativ hoch. Aber ich mache mir auch Sorgen, dass das Altcoin derzeit am Boden ist und aus einem steigenden Trend ausgeht und einen Verlust dieser Strategie verursacht.

Die zweite Strategie verwendet die Preisregressionsfunktion des Altcoins, die mehr als der Index steigt und eine hohe Wahrscheinlichkeit hat, zurückzufallen.

Aufgrund der unterschiedlichen Anlaufzeiten der Strategie und der spezifischen Parameter dürfte die Wirkung von Personen, die diese Strategie lange verwenden, nicht groß sein.

Kurz gesagt, es gibt keine perfekte Strategie, sondern nur eine richtige Einstellung zur Strategie.

Verwandt

Mehr