Chiến lược giao dịch cặp tiền kỹ thuật số

Chiến lược giao dịch cặp tiền kỹ thuật số

Lời giới thiệu

Gần đây đã thấy nhật ký định lượng của BUE đề cập đến việc có thể sử dụng các loại tiền tệ có liên quan tiêu cực để thực hiện tiền tệ, dựa trên sự phá vỡ chênh lệch giá để mở giao dịch để kiếm lợi nhuận. Các loại tiền kỹ thuật số về cơ bản đều có liên quan tích cực, liên quan tiêu cực là một số loại tiền tệ, thường có thị trường đặc biệt, chẳng hạn như thị trường độc lập của MEME tiền tệ trong thời gian trước, hoàn toàn không theo dõi xu hướng lớn, lọc ra các loại tiền tệ này, sau khi phá vỡ, làm nhiều, cách này có thể kiếm lợi nhuận trong một số trường hợp cụ thể.

Giao dịch cặp tiền kỹ thuật số là một chiến lược giao dịch dựa trên lợi nhuận thống kê, bằng cách mua và bán cùng một lúc hai hợp đồng tiền kỹ thuật số vĩnh cửu có liên quan mạnh mẽ để thu được lợi nhuận từ sự chênh lệch giá. Bài viết này sẽ trình bày chi tiết các nguyên tắc của chiến lược, cơ chế lợi nhuận, phương pháp lọc tiền, rủi ro tiềm ẩn và cách cải thiện chúng và cung cấp một số ví dụ mã Python thực tế.

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

Chiến lược giao dịch ghép nối phụ thuộc vào sự tương quan lịch sử giữa giá của hai loại tiền kỹ thuật số. Khi giá của hai loại tiền có sự tương quan mạnh mẽ, xu hướng giá của hai loại tiền này có thể tương đồng với nhau. Nếu tỷ lệ giá của hai loại tiền này có sự chênh lệch đáng kể tại một thời điểm nào đó, điều này có thể được coi là một sự bất thường tạm thời, và giá sẽ có xu hướng trở lại mức bình thường.

Giả sử coin A và coin B có mối tương quan giá cao. Trong một thời điểm nào đó, tỷ lệ giá A/B có giá trị trung bình là 1. Nếu tại một thời điểm nào đó, tỷ lệ giá A/B tăng vượt quá 0.001, tức vượt quá 1.001, thì giao dịch có thể được thực hiện theo cách sau: mua nhiều hơn B, mua nhiều hơn A. Ngược lại, khi tỷ lệ giá A/B thấp hơn 0.999, mua nhiều hơn A, mua nhiều hơn B.

Khóa khóa cho lợi nhuận là lợi nhuận chênh lệch khi giá biến mất trở lại bình thường. Bởi vì chênh lệch giá thường ngắn ngủi, các nhà giao dịch có thể đứng yên khi giá quay trở lại mức trung bình, kiếm lợi nhuận từ đó, kiếm được chênh lệch.

Dữ liệu sẵn sàng

Đưa ra thư viện

Các mã này có thể được sử dụng trực tiếp, tốt nhất là tải về một Anancoda và gỡ lỗi trong máy tính xách tay Jupyer.

import requests
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests, zipfile, io
%matplotlib inline

Nhập tất cả các cặp giao dịch đang được giao dịch

Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
b_symbols = [s['symbol'] for s in Info.json()['symbols'] if s['contractType'] == 'PERPETUAL' and s['status'] == 'TRADING' and s['quoteAsset'] == 'USDT']
b_symbols = list(filter(lambda x: x[-4:] == 'USDT', [s.split('_')[0] for s in b_symbols]))
b_symbols = [x[:-4] for x in b_symbols]
print(b_symbols) # 获取所有的正在交易的交易对

Chức năng tải xuống dòng K

Chức năng chính của GetKlines là lấy dữ liệu K-line lịch sử của các giao dịch được chỉ định đối với các hợp đồng vĩnh cửu từ sàn giao dịch Bitcoin và lưu trữ dữ liệu này trong một Pandas DataFrame. Dữ liệu K-line bao gồm thông tin về giá mở, giá cao nhất, giá thấp nhất, giá đóng, khối lượng giao dịch.

def GetKlines(symbol='BTCUSDT',start='2020-8-10',end='2024-7-01',period='1h',base='fapi',v = 'v1'):
    Klines = []
    start_time = int(time.mktime(datetime.strptime(start, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
    end_time =  min(int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000,time.time()*1000)
    intervel_map = {'m':60*1000,'h':60*60*1000,'d':24*60*60*1000}
    while start_time < end_time:
        time.sleep(0.3)
        mid_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
        url = 'https://'+base+'.binance.com/'+base+'/'+v+'/klines?symbol=%s&interval=%s&startTime=%s&endTime=%s&limit=1000'%(symbol,period,start_time,mid_time)
        res = requests.get(url)
        res_list = res.json()
        if type(res_list) == list and len(res_list) > 0:
            start_time = res_list[-1][0]+int(period[:-1])*intervel_map[period[-1]]
            Klines += res_list
        if type(res_list) == list and len(res_list) == 0:
            start_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
        if mid_time >= end_time:
            break
    df = pd.DataFrame(Klines,columns=['time','open','high','low','close','amount','end_time','volume','count','buy_amount','buy_volume','null']).astype('float')
    df.index = pd.to_datetime(df.time,unit='ms')
    return df

Quay dữ liệu

Số lượng dữ liệu tương đối lớn, chỉ lấy dữ liệu K-line giờ trong 3 tháng gần đây để tải xuống nhanh hơn.df_close chứa dữ liệu giá đóng cửa của tất cả các loại tiền tệ.

start_date = '2024-04-01'
end_date   = '2024-07-05'
period = '1h'
df_dict = {}

for symbol in b_symbols:   
    print(symbol)
    if symbol in df_dict.keys():
        continue
    df_s = GetKlines(symbol=symbol+'USDT',start=start_date,end=end_date,period=period)
    if not df_s.empty:
        df_dict[symbol] = df_s
df_close = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
for symbol in symbols:
    df_close[symbol] = df_dict[symbol].close
df_close = df_close.dropna(how='all')

Động cơ kiểm tra lại

Định nghĩa một đối tượng Exchange để sử dụng để kiểm tra lại sau

class Exchange:
    def __init__(self, trade_symbols, fee=0.0002, initial_balance=10000):
        self.initial_balance = initial_balance #初始的资产
        self.fee = fee
        self.trade_symbols = trade_symbols
        self.account = {'USDT':{'realised_profit':0, 'unrealised_profit':0, 'total':initial_balance,
                                'fee':0, 'leverage':0, 'hold':0, 'long':0, 'short':0}}
        for symbol in trade_symbols:
            self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0,'unrealised_profit':0,'fee':0}
            
    def Trade(self, symbol, direction, price, amount):
        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.fee #扣除手续费
        self.account['USDT']['fee'] += price*amount*self.fee
        self.account[symbol]['fee'] += price*amount*self.fee
        if cover_amount > 0: #先平仓
            self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #利润
            self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
            self.account[symbol]['amount'] -= -direction*cover_amount
            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[symbol]['hold_price'] = total_cost/total_amount
            self.account[symbol]['amount'] += direction*open_amount      
    
    def Buy(self, symbol, price, amount):
        self.Trade(symbol, 1, price, amount)
        
    def Sell(self, symbol, price, amount):
        self.Trade(symbol, -1, price, amount)
        
    def Update(self, close_price): #对资产进行更新
        self.account['USDT']['unrealised_profit'] = 0
        self.account['USDT']['hold'] = 0
        self.account['USDT']['long'] = 0
        self.account['USDT']['short'] = 0
        for symbol in self.trade_symbols:
            if not np.isnan(close_price[symbol]):
                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'] = self.account[symbol]['amount']*close_price[symbol]
                if self.account[symbol]['amount'] > 0:
                    self.account['USDT']['long'] += self.account[symbol]['value']
                if self.account[symbol]['amount'] < 0:
                    self.account['USDT']['short'] += self.account[symbol]['value']
                self.account['USDT']['hold'] += abs(self.account[symbol]['value'])
                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']['hold']/self.account['USDT']['total'],3)

Phân tích liên quan lọc tiền tệ

Tính tương quan là một phương pháp trong thống kê để đo mối quan hệ tuyến tính giữa hai biến. Phương pháp tính tương quan được sử dụng phổ biến nhất là hệ số tương quan của Pearson. Dưới đây là các nguyên tắc, công thức và phương pháp thực hiện tính tương quan.

• 1Biểu hiện sự tương quan hoàn toàn dương tính, hai biến luôn thay đổi đồng thời. Khi một biến gia tăng, biến khác cũng tăng theo tỷ lệ.
• -1Chỉ ra sự tương quan hoàn toàn tiêu cực, hai biến luôn thay đổi ngược lại. Càng gần -1 thì sự tương quan tiêu cực càng mạnh.
• 0Điều này có nghĩa là không dây liên quan, không có mối quan hệ trực tuyến giữa hai biến.

Các hệ số liên quan của Pearson được xác định bằng cách tính chênh lệch đồng chiều và chênh lệch tiêu chuẩn của hai biến. Công thức như sau:

[ \rho_{X,Y} = \frac{\text{cov}(X,Y) }{\sigma_X \sigma_Y} ]

Trong đó có:

• (\rho_{X,Y}) là số liên hệ Pearson của biến (X) và (Y).
• (\text{cov}(X,Y)) là chênh lệch đồng chiều của X và Y.
• (\sigma_X) và (\sigma_Y) là độ chênh lệch tiêu chuẩn của (X) và (Y)

Tất nhiên, không cần quan tâm đến cách tính toán, bạn có thể tính toán sự tương quan của tất cả các loại tiền tệ bằng cách sử dụng mã Python 1 dòng.

import seaborn as sns
corr = df_close.corr()
plt.figure(figsize=(20, 20))
sns.heatmap(corr, annot=False, cmap='coolwarm', vmin=-1, vmax=1)
plt.title('Correlation Heatmap of Cryptocurrency Closing Prices', fontsize=20);

Theo độ liên quan, 20 cặp tiền tệ có liên quan nhất được lọc ra. Kết quả là như sau. Tất cả chúng đều có liên quan rất mạnh, đều trên 0,99.

MANA     SAND     0.996562
ICX      ZIL      0.996000
STORJ    FLOW     0.994193
FLOW     SXP      0.993861
STORJ    SXP      0.993822
IOTA     ZIL      0.993204
         SAND     0.993095
KAVA     SAND     0.992303
ZIL      SXP      0.992285
         SAND     0.992103
DYDX     ZIL      0.992053
DENT     REEF     0.991789
RDNT     MANTA    0.991690
STMX     STORJ    0.991222
BIGTIME  ACE      0.990987
RDNT     HOOK     0.990718
IOST     GAS      0.990643
ZIL      HOOK     0.990576
MATIC    FLOW     0.990564
MANTA    HOOK     0.990563

Có thể bạn có thể tìm hiểu thêm về cách sử dụng mã này.

corr_pairs = corr.unstack()

# 移除自身相关性（即对角线上的值）
corr_pairs = corr_pairs[corr_pairs != 1]

sorted_corr_pairs = corr_pairs.sort_values(kind="quicksort")

# 提取最相关和最不相关的前20个币种对
most_correlated = sorted_corr_pairs.tail(40)[::-2]

print("最相关的前20个币种对：")
print(most_correlated)

Kiểm tra lại

Các mã phản hồi cụ thể như sau. Các bước cụ thể trong chiến lược biểu diễn là quan sát tỷ lệ giá của hai loại tiền điện tử (IOTA và ZIL) và giao dịch dựa trên sự thay đổi của tỷ lệ này.

1. Khởi động：

   • Định nghĩa các cặp giao dịch (pair_a = IOTA, pair_b = ZIL)
   • Tạo một đối tượng giao dịcheTrong khi đó, số tiền giao dịch của bạn sẽ được trả cho các khách hàng khác.
   • Tính toán tỷ lệ giá trung bình ban đầuavg。
   • Đặt giá trị giao dịch ban đầuvalue = 1000。

2. Xử lý định kỳ dữ liệu giá：

   • Dữ liệu giá trên mọi thời điểmdf_close。
   • Tính toán tỷ lệ giá hiện tại so với mức trung bìnhdiff。
   • Giá trị giao dịch theo đường lệchaim_value, mỗi lần sai 0.01, giao dịch một giá trị. Và quyết định giao dịch mua bán dựa trên tài khoản hiện tại và tình hình giá.
   • Nếu sự lệch quá lớn, thực hiện bán.pair_avà muapair_bCác hoạt động.
   • Nếu sai lệch quá nhỏ, thực hiện muapair_avà bánpair_bCác hoạt động.

3. Điều chỉnh trung bình：

   • Cập nhật tỷ lệ giá trung bìnhavgTheo đó, các nhà đầu tư sẽ có thể tham gia vào các hoạt động này.

4. Cập nhật tài khoản và hồ sơ：

   • Thông tin giữ và số dư tài khoản trên sàn giao dịch được cập nhật.
   • Ghi lại từng bước của tài khoản (tổng tài sản, tài sản nắm giữ, chi phí giao dịch, nhiều và không)res_list。

5. Kết quả xuất：

   • sẽres_listChuyển đổi thành khung dữ liệuresNhững người tham gia cuộc thi đã được mời đến tham gia cuộc thi.

pair_a = 'IOTA'
pair_b = "ZIL"
e = Exchange([pair_a,pair_b], fee=0.0002, initial_balance=10000) #Exchange定义放在评论区
res_list = []
index_list = []
avg = df_close[pair_a][0] / df_close[pair_b][0]
value = 1000
for idx, row in df_close.iterrows():
    diff = (row[pair_a] / row[pair_b] - avg)/avg
    aim_value = -value * diff / 0.01
    if -aim_value + e.account[pair_a]['amount']*row[pair_a] > 0.5*value:
        e.Sell(pair_a,row[pair_a],(-aim_value + e.account[pair_a]['amount']*row[pair_a])/row[pair_a])
        e.Buy(pair_b,row[pair_b],(-aim_value - e.account[pair_b]['amount']*row[pair_b])/row[pair_b])
    if -aim_value + e.account[pair_a]['amount']*row[pair_a]  < -0.5*value:
        e.Buy(pair_a, row[pair_a],(aim_value - e.account[pair_a]['amount']*row[pair_a])/row[pair_a])
        e.Sell(pair_b, row[pair_b],(aim_value + e.account[pair_b]['amount']*row[pair_b])/row[pair_b])
    avg = 0.99*avg + 0.01*row[pair_a] / row[pair_b]
    index_list.append(idx)
    e.Update(row)
    res_list.append([e.account['USDT']['total'],e.account['USDT']['hold'],
                         e.account['USDT']['fee'],e.account['USDT']['long'],e.account['USDT']['short']])
res = pd.DataFrame(data=res_list, columns=['total','hold', 'fee', 'long', 'short'],index = index_list)
res['total'].plot(grid=True);

Kết quả là khá lý tưởng. Các tính toán tương quan hiện tại được sử dụng dữ liệu tương lai, do đó không chính xác. Bài viết cũng chia dữ liệu thành hai phần, dựa trên tính toán tương quan trước đó, các kết quả giao dịch được kiểm tra lại sau đó.

Rủi ro tiềm ẩn và cách cải thiện

Mặc dù các chiến lược giao dịch ghép đôi có thể lợi nhuận về lý thuyết, nhưng vẫn có một số rủi ro trong hoạt động thực tế: mối quan hệ giữa các loại tiền tệ có thể thay đổi theo thời gian, khiến chiến lược không hiệu quả; trong điều kiện thị trường cực đoan, sự lệch giá có thể gia tăng, dẫn đến tổn thất lớn hơn; một số loại tiền tệ có tính thanh khoản thấp, có thể làm cho giao dịch khó thực hiện hoặc tăng chi phí; chi phí thủ tục phát sinh từ giao dịch thường xuyên có thể làm xói mòn lợi nhuận.

Để giảm rủi ro và nâng cao tính ổn định của chiến lược, các cải tiến sau đây có thể được xem xét: thường xuyên tính lại sự tương quan giữa các cặp tiền tệ, điều chỉnh các cặp giao dịch kịp thời; đặt điểm dừng lỗ và điểm dừng để kiểm soát tổn thất tối đa của một giao dịch; đồng thời giao dịch nhiều cặp tiền tệ, phân tán rủi ro.

Kết luận

Chiến lược giao dịch cặp tiền kỹ thuật số đạt được lợi nhuận bằng cách tận dụng sự liên quan của giá đồng tiền để vận hành lợi nhuận khi giá lệch. Chiến lược này có tính khả thi lý thuyết cao hơn. Sau đó, một mã nguồn chiến lược thực đơn đơn giản dựa trên chiến lược sẽ được phát hành.