Nghiên cứu về Binance Futures Multi-currency Hedging Strategy Phần 1

Nghiên cứu về Binance Futures Multi-currency Hedging Strategy Phần 1

Nhấp vào nút tìm kiếm trên trang Bảng điều khiển, sau đó nhấp vào mũi tên để nhập. Mở tệp hậu tố.pynb đã tải lên và nhấn shift + enter để chạy từng dòng. Có các hướng dẫn cơ bản trong trợ giúp sử dụng của môi trường nghiên cứu.

Lý do chiến lược

Binance đã liệt kê nhiều altcoin tại chỗ. Mặc dù sự biến động ngắn hạn là không chắc chắn, nhưng nếu bạn nhìn vào đường hàng ngày trong một thời gian dài, bạn sẽ thấy rằng chúng cơ bản đã giảm hơn 90%, và một số thậm chí chỉ có một phần của phần giá cao nhất. Tuy nhiên, không có phương pháp bán ngắn phổ biến cho điểm, và không có khuyến nghị đặc biệt nào ngoại trừ không chạm vào altcoin. Trong hai tháng qua, Binance Futures đã tung ra hơn 20 hợp đồng vĩnh viễn, hầu hết là các loại tiền tệ chính thống, và một số là không rõ. Điều này cho chúng ta phương tiện để bán ngắn các kết hợp altcoin này. Sử dụng hệ số tương quan giữa altcoin và BTC sẽ là một phương pháp phân tích hiệu quả, hai chiến lược có thể được thiết kế.

Nguyên tắc chiến lược

Chiến lược đầu tiên: bán ngắn giỏ altcoin được chọn trong một tương đương phi tập trung, và đồng thời mua dài cùng một lượng vị trí BTC để bảo hiểm, để giảm rủi ro và biến động. Khi giá dao động, liên tục điều chỉnh vị trí để giữ giá trị vị trí ngắn không đổi và bằng với vị trí dài. Về cơ bản, đó là một hoạt động bán ngắn chỉ số giá altcoin-bitcoin.

Chiến lược thứ hai: bán ngắn các loại tiền tệ có giá cao hơn chỉ số giá altcoin-bitcoin, và mong muốn với các loại tiền tệ thấp hơn chỉ số, càng lớn độ lệch, càng lớn vị trí.

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

Hiển thị đồng tiền cần thiết

Hợp đồng vĩnh cửu Binance hiện đang liệt kê các loại tiền tệ, có thể được lấy bằng cách sử dụng giao diện API của nó, tổng số là 23 (không bao gồm 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']

Đầu tiên, hãy nghiên cứu xu hướng giá của altcoin so với Bitcoin trong năm qua. Tôi đã tải dữ liệu trước và đăng nó lên diễn đàn, có thể được trích dẫn trực tiếp trong môi trường nghiên cứu.

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

Kết quả:

5 hàng × 23 cột

Đầu tiên vẽ giá của các loại tiền tệ này để xem xu hướng, dữ liệu nên được bình thường hóa.

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

Bằng cách sắp xếp các thay đổi giá gần đây, bạn có thể tìm thấy một số đồng tiền rõ ràng khác nhau, cụ thể là LINK, XTZ, BCH, ETH. Giải thích rằng chúng thường có thể chạy xu hướng của riêng chúng, và bán ngắn chúng có rủi ro cao hơn và cần phải loại trừ khỏi chiến lược.

Kéo bản đồ nhiệt của hệ số tương quan của các loại tiền tệ còn lại, và thấy rằng xu hướng của ETC và ATOM cũng tương đối đặc biệt và có thể bị loại trừ.

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

Kết quả:

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

Các đồng tiền cuối cùng còn lại đã giảm trung bình 66% mỗi năm, rõ ràng là có nhiều chỗ cho việc bán ngắn. tổng hợp xu hướng của các đồng tiền này vào chỉ số giá altcoin, nó được tìm thấy rằng nó về cơ bản đã giảm tất cả các cách, nó ổn định hơn trong nửa sau của năm ngoái, và bắt đầu giảm tất cả các cách trong năm nay. Nghiên cứu này sàng lọc LINK, XTZ, BCH, ETH, ETC, ATOM, BNB, EOS, LTC không tham gia vào việc bán ngắn của chiến lược đầu tiên, chi tiết cụ thể có thể được kiểm tra lại bởi chính bạn.

Cần lưu ý rằng chỉ số altcoin hiện tại đang ở mức thấp nhất trong năm qua. Có lẽ đó không phải là một cơ hội mua ngắn, mà là một cơ hội mua dài. bạn phải tự quyết định nó.

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

Kết quả:

0.6714306758250285

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

Dữ liệu bền vững của Binance

Tương tự như vậy, dữ liệu về Binance Sustainability đã được tổng hợp, bạn cũng có thể trực tiếp trích dẫn nó trong sổ ghi chép của mình, dữ liệu là đường K thị trường 1h từ ngày 28 tháng 1 đến ngày 31 tháng 3 năm 2020, bởi vì hầu hết các hợp đồng vĩnh cửu của Binance đã được ăn trưa chỉ hai tháng, vì vậy dữ liệu là đủ để kiểm tra lại.

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

Kết quả:

Đầu tiên nhìn vào xu hướng tổng thể với dữ liệu bình thường. Trong sự sụt giảm tháng Ba, so với giá vào đầu tháng Hai, giá nói chung đã giảm, cho thấy rủi ro của hợp đồng vĩnh viễn cũng rất cao.

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

Kéo giá chỉ số của đồng tiền chúng ta muốn bán so với Bitcoin, nguyên tắc chiến lược là rút ngắn đường cong này, và lợi nhuận về cơ bản là ngược lại của đường cong này.

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

Động cơ thử nghiệm ngược

Bởi vì FMZ backtest địa phương không có dữ liệu cho tất cả các loại tiền tệ và không hỗ trợ backtest đa tiền tệ, cần phải thực hiện lại một công cụ backtest. Vì vậy, tôi đã viết một công cụ backtest mới, nó tương đối đơn giản, nhưng về cơ bản là đủ. Xét về phí giao dịch, nhưng về cơ bản bỏ qua tỷ lệ vốn, không xem xét tình hình duy trì vốn ký quỹ. Tổng vốn, ký quỹ chiếm đóng và đòn bẩy đã được ghi nhận. Vì chiến lược này có thuộc tính rằng vị trí dài bằng vị trí ngắn, vì vậy tác động của tỷ lệ vốn không đáng kể.

Việc kiểm tra lại không tính đến tình huống trượt giá, bạn có thể tự tăng mô phỏng phí giao dịch, xem xét phí giao dịch thấp của nhà sản xuất Binance, ngay cả sự khác biệt giá trong thị trường tiền tệ không phổ biến là rất nhỏ, bạn có thể sử dụng phương pháp hoa hồng băng ở thị trường thực khi đặt đơn đặt hàng, tác động không nên đáng kể.

Khi tạo một đối tượng trao đổi, bạn cần phải chỉ định loại tiền tệ được giao dịch. Mua là dài và Bán là ngắn. Do giới hạn hợp đồng vĩnh cửu, khi mở vị trí, các vị trí dài và ngắn sẽ tự động đóng cùng nhau. Khi bán vị trí ngắn và số tiền tệ là âm. Các thông số là như sau:

• trade_symbols: danh sách các loại tiền tệ được giao dịch
• đòn bẩy: đòn bẩy, ký quỹ ảnh hưởng,
• Phụ phí: phí giao dịch, mặc định 0,00005
• initial_balance: tài sản ban đầu, định giá USDT
• log: có nên in các bản ghi giao dịch hay không

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

Mã chiến lược đầu tiên

Chiến lược logic:

• Kiểm tra giá tiền tệ, nếu không nan, bạn có thể giao dịch
• Kiểm tra giá trị của hợp đồng altcoin. Nếu nó thấp hơn giá trị mục tiêu trade_value, sự khác biệt tương ứng sẽ được bán ngắn, và nếu lớn hơn, số tiền tương ứng sẽ được mua để đóng vị trí.
• Thêm giá trị ngắn của tất cả các altcoin và điều chỉnh vị trí BTC để phòng ngừa chống lại nó.

Vị trí short trade_value xác định kích thước của vị trí.

# 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

Lợi nhuận cuối cùng của mỗi loại tiền tệ là như sau:

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

Hai biểu đồ dưới đây là đường cong tài sản ròng và đòn bẩy được sử dụng.

Màu vàng trong đường cong giá trị ròng là tác động của đòn bẩy 1x giảm chỉ số altcoin. Có thể thấy rằng chiến lược về cơ bản khuếch đại sự biến động của chỉ số, phù hợp với mong đợi. Lợi nhuận hai tháng cuối cùng là 60%, khôi phục tối đa là 20%, và đòn bẩy tối đa là khoảng 8 lần. Hầu hết thời gian, nó ít hơn 6 lần. Nó vẫn an toàn. Quan trọng nhất, việc bảo hiểm hoàn toàn đã khiến chiến lược mất rất ít trong sự sụp đổ ngày 12 tháng 3.

Khi giá đồng tiền bán ngắn tăng và giá trị hợp đồng tăng, vị trí sẽ giảm, mặt khác, khi kiếm được lợi nhuận, vị trí sẽ tăng.

Nhưng rủi ro cũng đã được đề cập trước đó, altcoin rất có khả năng chạy xu hướng của riêng mình, và có thể tăng rất nhiều từ đáy. Nó phụ thuộc vào cách sử dụng nó. Nếu bạn lạc quan về altcoin và nghĩ rằng nó đã đạt đến đáy, bạn có thể hoạt động theo hướng và mua dài chỉ số này. Hoặc nếu bạn lạc quan về một số loại tiền tệ nhất định, bạn có thể phòng ngừa với chúng.

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

Ngoài ra, vì giá của altcoin so với USDT cũng giảm, kế hoạch cực đoan không được bảo hiểm, bán trực tiếp ngắn, nhưng sự biến động rất lớn và khôi phục cao

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

Mã chiến lược thứ hai

Chiến lược logic:

• Kiểm tra xem có giá hoặc có giá để giao dịch
• Kiểm tra độ lệch của giá tiền tệ từ chỉ số
• Đi dài và ngắn dựa trên sự đánh giá sai lệch, và đánh giá vị trí theo kích thước sai lệch
• Tính toán các vị trí không được bảo hiểm và bảo hiểm bằng BTC

Trade_value cũng kiểm soát kích thước của các vị trí mở. Bạn cũng có thể sửa đổi yếu tố chuyển đổi của diff/0.001

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

Lợi nhuận của chiến lược thứ hai tốt hơn nhiều so với chiến lược đầu tiên. Trong hai tháng qua, nó có lợi nhuận 100%, nhưng vẫn có sự thoái lui 20%. Trong tuần qua, do biến động thị trường nhỏ, lợi nhuận không rõ ràng. Lợi nhuận tổng thể không nhiều. Chiến lược này đáng để thử. Tùy thuộc vào mức độ lệch, nhiều hơn 7800 vị trí USDT đã được mở tối đa.

Lưu ý rằng nếu một đồng tiền chạy một xu hướng độc lập, ví dụ, nó đã tăng nhiều lần so với chỉ số, nó sẽ tích lũy một số lượng lớn các vị trí ngắn trong đồng tiền, và cùng một sự sụt giảm mạnh cũng sẽ làm cho chiến lược mua dài, có thể hạn chế vị trí mở tối đa.

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

Nếu kết quả của việc không bảo hiểm là như sau, sự khác biệt thực sự không nhiều. bởi vì các vị trí dài và ngắn về cơ bản là cân bằng.

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

Nếu bạn đề cập đến sự hồi quy giá USDT, hiệu ứng sẽ tồi tệ hơn nhiều

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

Nếu bạn giới hạn giá trị vị trí tối đa, hiệu suất sẽ tồi tệ hơn

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

Tóm lại và rủi ro

Chiến lược đầu tiên tận dụng thực tế rằng giá trị tổng thể của altcoin không tốt như bitcoin. Nếu bạn mua bitcoin dài, bạn có thể muốn gắn bó với chiến lược này trong một thời gian dài. Do tương đương các vị trí dài và ngắn, về cơ bản bạn không sợ tỷ lệ tài trợ 8h. Về lâu dài, tỷ lệ thắng tương đối cao. Nhưng tôi cũng lo lắng rằng altcoin hiện đang ở đáy, và nó có thể chạy ra khỏi xu hướng tăng và gây ra tổn thất cho chiến lược này.

Chiến lược thứ hai sử dụng tính năng hồi quy giá của altcoin, tăng nhiều hơn chỉ số và có khả năng giảm trở lại cao. Tuy nhiên, nó có thể tích lũy quá nhiều vị trí trong một loại tiền tệ duy nhất. Nếu một loại tiền tệ nhất định thực sự không giảm, nó sẽ gây ra tổn thất lớn.

Do thời gian khởi động khác nhau của chiến lược và các tham số cụ thể, tác động của những người sử dụng chiến lược này trong một thời gian dài không nên lớn.

Nói tóm lại, không có chiến lược hoàn hảo, chỉ có một thái độ chính xác đối với chiến lược, nó cuối cùng phụ thuộc vào sự hiểu biết của người dùng về rủi ro và đánh giá về tương lai.

Có liên quan

Thêm nữa