Strategi perdagangan pasangan mata wang digital terperinci

Strategi perdagangan pasangan mata wang digital terperinci

Pengantar

Baru-baru ini melihat buku harian Kuantitatif BUE yang menyebut bahawa anda boleh menggunakan mata wang yang berkaitan negatif untuk melakukan mata wang, berdasarkan penembusan perbezaan harga untuk membuka dagangan untuk memperoleh keuntungan. Mata wang digital pada dasarnya adalah berkaitan positif, yang berkaitan negatif adalah beberapa mata wang, yang sering mempunyai pasaran khas, seperti pasaran bebas mata wang MEME pada masa lalu, tidak mengikuti trend besar, memilih mata wang ini, dan melakukan lebih banyak selepas penembusan, cara ini dapat menguntungkan dalam keadaan tertentu. Tetapi penggunaan yang paling biasa dalam bidang perdagangan Kuantitatif adalah untuk melakukan perdagangan pasangan yang positif, artikel ini akan memberi gambaran ringkas mengenai strategi ini.

Perdagangan pasangan mata wang digital adalah strategi dagangan berdasarkan keuntungan statistik, dengan membeli dan menjual kedua-dua kontrak kekal mata wang digital yang sangat berkaitan secara serentak untuk mendapatkan keuntungan daripada perpindahan harga. Artikel ini akan menerangkan prinsip, mekanisme keuntungan, kaedah menyaring mata wang, risiko yang berpotensi dan cara untuk memperbaikinya, serta memberikan beberapa contoh kod Python yang berguna.

Prinsip-prinsip strategi

Strategi perdagangan berpasangan bergantung pada perkaitan sejarah antara harga dua mata wang digital. Apabila dua mata wang menunjukkan perkaitan yang kuat, pergerakan harga mereka hampir serentak. Jika perbandingan harga kedua-dua mata wang muncul pada satu ketika, ini boleh dianggap sebagai kelainan sementara, dengan harga cenderung kembali ke tahap normal. Pasaran mata wang digital mempunyai ketersediaan yang tinggi, dan apabila satu mata wang digital utama (seperti Bitcoin) mengalami turun naik yang besar, biasanya tindak balas ketersediaan mata wang digital lain akan timbul.

Misalkan mata wang A dan mata wang B mempunyai perkaitan harga yang lebih tinggi. Pada satu ketika, purata nilai nisbah harga A/B adalah 1. Jika pada satu ketika, harga nisbah A/B meningkat lebih daripada 0.001, iaitu lebih daripada 1.001, maka perdagangan boleh dilakukan dengan cara berikut: buka lebih banyak B, buka lebih banyak A. Sebaliknya, apabila nisbah harga A/B lebih rendah daripada 0.999: buka lebih banyak A, buka lebih banyak B.

Kunci keuntungan adalah keuntungan perbezaan apabila harga menyimpang kembali normal. Oleh kerana perbezaan harga biasanya singkat, peniaga boleh menghampiri ketika harga kembali ke rata-rata dan memperoleh keuntungan daripadanya, memperoleh perbezaan.

Persediaan data

Memperkenalkan perpustakaan

Kod-kod ini boleh digunakan secara langsung, dan lebih baik memuat turun Anancoda, untuk di-debug dalam buku nota 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

Dapatkan semua pasangan dagangan yang sedang ditukar

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) # 获取所有的正在交易的交易对

Fungsi untuk memuat turun garis K

Fungsi utama fungsi GetKlines ialah untuk mendapatkan data K-line sejarah bagi kontrak kekal yang ditandatangani dari bursa mata wang Binance dan menyimpan data ini dalam satu Pandas DataFrame. Data K-line termasuk maklumat mengenai harga buka, harga tertinggi, harga terendah, harga penutupan, jumlah dagangan. Pada kali ini, kita menggunakan data harga penutupan.

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

Mengunduh data

Data yang agak besar, untuk muat turun yang lebih cepat, hanya mendapatkan data K-Line jam 3 bulan terakhir;df_close mengandungi data harga penutupan semua mata wang

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

Enjin pengukuran semula

Menentukan objek Exchange untuk digunakan untuk pemeriksaan semula seterusnya

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)

Analisis perkaitan untuk menyaring mata wang

Perbandingan perbandingan adalah satu kaedah dalam statistik untuk mengukur hubungan linear antara dua pembolehubah. Kaedah pengiraan perbandingan yang paling biasa digunakan ialah faktor perbandingan Pearson. Berikut adalah prinsip, formula, dan kaedah pelaksanaan perbandingan. Faktor perbandingan Pearson digunakan untuk mengukur hubungan linear antara dua pembolehubah, mengambil nilai dalam julat antara -1 hingga 1:

• 1Menunjukkan bahawa kedua-dua pembolehubah sentiasa berubah secara serentak. Apabila satu pembolehubah meningkat, pembolehubah lain juga meningkat secara proporsi. Semakin dekat 1 mewakili hubungan yang lebih kuat.
• -1Menunjukkan hubungan negatif sepenuhnya, dua pembolehubah sentiasa berubah secara terbalik. Semakin dekat -1 menunjukkan hubungan negatif yang lebih kuat.
• 0Menunjukkan hubungan tanpa wayar, tidak ada hubungan lurus antara dua pembolehubah.

Koefisien hubungan Pearson ditentukan dengan mengira perbezaan sisi dan perbezaan standard kedua-dua pembolehubah. Rumusnya ialah:

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

Di antaranya:

• ( \rho_{X,Y}) adalah peguam Pearson bagi pembolehubah (X) dan (Y).
• (\text{cov}(X,Y)) adalah perbezaan kos (X) dan (Y).
• (\sigma_X) dan (\sigma_Y) adalah perbezaan standard antara (X) dan (Y), masing-masing.

Sudah tentu, tanpa terlalu mementingkan bagaimana ia dikira, anda boleh menggunakan kod baris 1 Python untuk mengira kesesuaian semua mata wang. Gambar ini menunjukkan carta panas kesesuaian, perwakilan merah adalah berkaitan positif, perwakilan biru adalah berkaitan negatif, dan semakin mendalam warna, semakin kuat kesesuaian.

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

Berdasarkan kesesuaian, 20 pasangan mata wang yang paling relevan dipilih. Hasilnya adalah sebagai berikut. Kesesuaian mereka sangat kuat, semuanya lebih daripada 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

Kod yang berkaitan adalah sebagai berikut:

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)

Ujian semula

Kod pengulangan khusus adalah seperti berikut: Langkah-langkah tertentu adalah sebagai berikut:

1. Permulaan：

   • Definisi pasangan dagangan ((pair_a = IOTA, pair_b = ZIL) ).
   • Buat objek pertukaraneDengan baki awal $ 10,000, yuran urus niaga adalah 0.02%.
   • Mengira nisbah harga purata awalavg。
   • Tetapkan nilai transaksi awalvalue = 1000。

2. Pengolahan data harga secara berkala：

   • Data harga di setiap titik masadf_close。
   • Mengira perpindahan nisbah harga semasa berbanding puratadiff。
   • Nilai urus niaga berdasarkan deviasiaim_value, untuk setiap penyimpangan 0.01, perdagangan satu nilai. dan membuat keputusan untuk membeli dan menjual operasi berdasarkan pemegang akaun semasa dan keadaan harga.
   • Jika kecacatan terlalu besar, lakukan jualan.pair_adan membelipair_bOperasi.
   • Jika kecacatan terlalu kecil, buat pembelianpair_adan menjualpair_bOperasi.

3. Penyesuaian purata：

   • Mengemas kini nisbah harga purataavgPerbandingan harga terkini akan dilihat di laman web ini.

4. Mengemas kini akaun dan rekod：

   • Mengemas kini maklumat simpanan dan baki akaun bursa.
   • Mencatatkan keadaan akaun setiap langkah (total aset, aset yang dipegang, bayaran urus niaga, banyak dan kosong) sehinggares_list。

5. Hasil output：

   • akanres_listMengubah kepada bingkai dataresDi samping itu, ia juga mempunyai ciri-ciri yang berbeza.

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

Hasil yang lebih baik. Perkiraan hubungan semasa menggunakan data masa depan, jadi tidak tepat. Artikel ini juga membahagikan data untuk dua bahagian, berdasarkan hubungan perhitungan sebelumnya, hasil transaksi yang diuji semula kemudian. Hasil transaksi agak buruk tetapi tidak baik.

Potensi risiko dan cara memperbaiki

Walaupun strategi perdagangan berpasangan secara teori boleh menguntungkan, terdapat beberapa risiko dalam operasi sebenar: hubungan antara mata wang boleh berubah dari masa ke masa, menyebabkan strategi gagal; dalam keadaan pasaran yang melampau, penyimpangan harga boleh meningkat, menyebabkan kerugian yang lebih besar; kecairan mata wang tertentu yang lebih rendah, yang boleh menyebabkan transaksi sukar dilaksanakan atau meningkatkan kos; yuran pengendalian yang dihasilkan oleh perdagangan yang kerap boleh merosakkan keuntungan.

Untuk mengurangkan risiko dan meningkatkan kestabilan strategi, langkah-langkah penambahbaikan berikut boleh dipertimbangkan: menghitung semula hubungan antara mata wang secara berkala, menyesuaikan pasangan dagangan pada masa yang sesuai; menetapkan stop loss dan stop target, mengawal kerugian maksimum untuk perdagangan tunggal; memperdagangkan beberapa pasangan mata wang pada masa yang sama, menyebarkan risiko.

Kesimpulan

Strategi perdagangan pasangan mata wang digital menghasilkan keuntungan dengan memanfaatkan perkaitan harga mata wang untuk melakukan operasi pilihan apabila harga menyimpang. Strategi ini mempunyai kelayakan teori yang lebih tinggi. Kod sumber strategi riil yang mudah berdasarkan strategi ini akan dikeluarkan kemudian. Jika terdapat lebih banyak soalan atau perlu dibincangkan lebih lanjut, silakan hubungi kami.