Penelitian tentang Binance Futures Multi-currency Hedging Strategy Bagian 1

Penelitian tentang Binance Futures Multi-currency Hedging Strategy Bagian 1

Klik tombol pencarian di halaman Dashboard, lalu klik panah untuk masuk. Buka file akhiran.pynb yang diunggah dan tekan shift + enter untuk menjalankan baris demi baris. Ada tutorial dasar dalam bantuan pengguna lingkungan penelitian.

Alasan Strategi

Binance telah mencantumkan banyak altcoin di tempat. Meskipun fluktuasi jangka pendek tidak pasti, jika Anda melihat garis harian untuk waktu yang lama, Anda akan menemukan bahwa mereka pada dasarnya telah turun lebih dari 90%, dan beberapa bahkan hanya memiliki pecahan dari fraksi harga tertinggi. Namun, tidak ada metode jual pendek universal untuk spot, dan tidak ada rekomendasi khusus kecuali untuk tidak menyentuh altcoin. Dalam dua bulan terakhir, Binance Futures telah meluncurkan lebih dari 20 kontrak abadi, yang sebagian besar adalah mata uang utama, dan beberapa tidak diketahui. Ini memberi kita sarana untuk short kombinasi altcoin ini. Menggunakan koefisien korelasi antara altcoin dan BTC akan menjadi metode analisis yang efektif, dua strategi dapat dirancang.

Prinsip-prinsip strategi

Strategi pertama: Menjual pendek keranjang altcoin yang dipilih dalam setara terdesentralisasi, dan pada saat yang sama membeli panjang jumlah posisi BTC yang sama untuk lindung nilai, untuk mengurangi risiko dan volatilitas. Ketika harga berfluktuasi, terus menyesuaikan posisi untuk menjaga nilai posisi pendek konstan dan sama dengan posisi panjang. Pada dasarnya ini adalah operasi yang menjual pendek indeks harga altcoin-bitcoin.

Strategi kedua: shorting mata uang dengan harga yang lebih tinggi dari indeks harga altcoin-bitcoin, dan merindukan mata uang yang lebih rendah dari indeks, semakin besar penyimpangan, semakin besar posisinya.

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

Tampilan mata uang yang dibutuhkan

Kontrak abadi Binance saat ini mencatatkan mata uang, yang dapat diperoleh dengan menggunakan antarmuka API, total 23 (tidak termasuk 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']

Pertama, mari s mempelajari pergerakan harga altcoin ke Bitcoin pada tahun lalu. saya telah mengunduh data sebelumnya dan mempostingnya ke forum, yang dapat langsung dikutip di lingkungan penelitian.

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

Hasilnya:

5 baris × 23 kolom

Pertama-tama gambar harga mata uang ini untuk melihat tren, data harus dinormalisasi.

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

Dengan menyortir perubahan harga terakhir, Anda dapat menemukan beberapa koin yang jelas berbeda, yaitu LINK, XTZ, BCH, ETH. Jelaskan bahwa mereka sering dapat menjalankan tren mereka sendiri, dan shorting mereka memiliki risiko yang lebih tinggi dan perlu dikecualikan dari strategi.

Buatlah peta panas dari koefisien korelasi dari mata uang yang tersisa, dan temukan bahwa tren ETC dan ATOM juga relatif khusus dan dapat dikecualikan.

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

Hasilnya:

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

Mata uang terakhir yang tersisa turun rata-rata 66% per tahun, jelas ada banyak ruang untuk shorting. Menyintesis tren koin ini ke dalam indeks harga altcoin, ditemukan bahwa pada dasarnya turun sepanjang jalan, lebih stabil di paruh kedua tahun lalu, dan mulai turun sepanjang tahun ini.

Perlu dicatat bahwa indeks altcoin saat ini berada di titik terendah tahun lalu.

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

Hasilnya:

0.6714306758250285

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

Data Keberlanjutan Binance

Demikian pula, data tentang Keberlanjutan Binance telah disusun, Anda juga dapat langsung mengutipnya di buku catatan Anda, data adalah garis K pasar 1 jam dari 28 Januari hingga 31 Maret 2020, karena sebagian besar kontrak abadi Binance telah makan siang hanya dua bulan, jadi data cukup untuk backtest.

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

Hasilnya:

Pertama melihat tren keseluruhan dengan data yang ternormalized. dalam kejatuhan Maret, relatif terhadap harga pada awal Februari, harga umumnya diturunkan, menunjukkan bahwa risiko kontrak abadi juga sangat tinggi. gelombang penurunan ini juga merupakan tes tantangan besar untuk strategi.

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

Gambar harga indeks koin yang ingin kita jual terhadap Bitcoin, prinsip strategi adalah untuk short kurva ini, dan pengembalian pada dasarnya kebalikan dari kurva ini.

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

Mesin backtest

Karena backtest lokal FMZ tidak memiliki data untuk semua mata uang dan tidak mendukung backtest multi-mata uang, perlu untuk menerapkan kembali mesin backtest. Jadi saya menulis mesin backtest baru, itu relatif sederhana, tetapi pada dasarnya cukup. Mengingat biaya transaksi, tetapi pada dasarnya mengabaikan tingkat modal, tidak mempertimbangkan situasi mempertahankan modal margin. Total ekuitas, margin yang diduduki, dan leverage dicatat. Karena strategi ini memiliki atribut bahwa posisi panjang sama dengan posisi pendek, sehingga dampak tingkat modal tidak signifikan.

Backtest tidak memperhitungkan situasi geser harga, Anda dapat meningkatkan simulasi biaya transaksi sendiri, mengingat biaya transaksi pembuat Binance yang rendah, bahkan perbedaan selisih harga di pasar mata uang yang tidak populer sangat kecil, Anda dapat menggunakan metode komisi gunung es di pasar nyata saat melakukan pesanan, dampaknya seharusnya tidak signifikan.

Saat membuat objek pertukaran, Anda perlu menentukan mata uang yang akan diperdagangkan. Beli adalah panjang dan Jual adalah pendek. Karena keterbatasan kontrak abadi, ketika membuka posisi, posisi panjang dan pendek secara otomatis ditutup bersama. Ketika menjual posisi pendek dan jumlah mata uang negatif. Parameternya adalah sebagai berikut:

• trade_symbols: daftar mata uang yang akan diperdagangkan
• leverage: leverage, margin mempengaruhi,
• Komisi: biaya transaksi, default 0,00005
• initial_balance: aset awal, valuasi USDT
• log: apakah untuk mencetak catatan transaksi

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

Kode strategi pertama

Logika strategi:

• Periksa harga mata uang, jika tidak nan, Anda dapat berdagang
• Periksa nilai kontrak altcoin. Jika kurang dari nilai target trade_value, perbedaan yang sesuai akan dijual pendek, dan jika lebih besar, jumlah yang sesuai akan dibeli untuk menutup posisi.
• Tambahkan nilai pendek dari semua altcoin dan sesuaikan posisi BTC untuk lindung nilai terhadapnya.

Posisi short trade_value menentukan ukuran posisi. Setting log = True akan mencetak log transaksi

# 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

Keuntungan akhir dari setiap mata uang adalah sebagai berikut:

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

Dua grafik di bawah ini adalah kurva kekayaan bersih dan leverage yang digunakan.

Warna kuning pada kurva kekayaan bersih adalah efek dari leverage 1x shorting indeks altcoin. Dapat dilihat bahwa strategi pada dasarnya memperkuat fluktuasi indeks, yang sesuai dengan harapan. Pengembalian dua bulan terakhir adalah 60%, retracement maksimum adalah 20%, dan leverage maksimum sekitar 8 kali. Sebagian besar waktu, itu kurang dari 6 kali. Masih aman. Yang paling penting, lindung nilai lengkap telah membuat strategi kehilangan sedikit dalam kejatuhan 12 Maret.

Ketika harga mata uang jual pendek naik dan nilai kontrak meningkat, posisi berkurang, di sisi lain, ketika mendapatkan keuntungan, posisi meningkat. Hal ini membuat nilai total kontrak konstan, bahkan jika jatuh meroket memiliki kerugian terbatas.

Tapi risiko juga disebutkan sebelumnya, altcoin sangat mungkin menjalankan tren mereka sendiri, dan dapat naik banyak dari bawah. Itu tergantung pada bagaimana Anda menggunakannya. Jika Anda optimis tentang altcoin dan berpikir bahwa itu telah mencapai dasar, Anda dapat beroperasi ke arah dan membeli panjang indeks ini. atau jika Anda optimis tentang mata uang tertentu, Anda dapat lindung nilai dengan mereka.

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

Selain itu, karena harga altcoin terhadap USDT juga turun, rencana ekstrim tidak dilindungi, langsung menjual pendek, tetapi fluktuasi sangat besar dan retracement tinggi

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

Kode strategi kedua

Logika strategi:

• Periksa apakah ada harga atau ada harga untuk perdagangan
• Periksa penyimpangan harga mata uang dari indeks
• Pergi panjang dan pendek berdasarkan penilaian penyimpangan, dan menilai posisi sesuai dengan ukuran penyimpangan
• Menghitung posisi yang tidak dilindungi dan lindung nilai dengan BTC

Trade_value juga mengontrol ukuran posisi terbuka. Anda juga dapat memodifikasi faktor konversi dari 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

Strategi kedua memiliki laba yang jauh lebih baik dari strategi pertama. Dalam dua bulan terakhir, ia memiliki laba 100%, tetapi masih memiliki retracement 20%. Dalam seminggu terakhir, karena fluktuasi pasar yang kecil, laba tidak jelas. Leverage secara keseluruhan tidak banyak. Strategi ini layak dicoba. Tergantung pada tingkat penyimpangan, lebih dari 7800 posisi USDT dibuka paling banyak.

Perhatikan bahwa jika mata uang menjalankan tren independen, misalnya, telah meningkat beberapa kali relatif terhadap indeks, ia akan mengumpulkan sejumlah besar posisi pendek dalam mata uang, dan penurunan tajam yang sama juga akan membuat strategi untuk membeli panjang, yang dapat membatasi posisi pembukaan maksimum.

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

Jika hasil dari tidak lindung nilai adalah sebagai berikut, perbedaan sebenarnya tidak banyak. karena posisi panjang dan pendek pada dasarnya seimbang.

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

Jika Anda merujuk pada regresi harga USDT, efeknya akan jauh lebih buruk

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

Jika Anda membatasi nilai posisi maksimum, kinerja akan lebih buruk

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

Ringkasan dan Risiko

Strategi pertama mengambil keuntungan dari fakta bahwa nilai keseluruhan altcoin tidak sebagus bitcoin. Jika Anda membeli bitcoin panjang, Anda mungkin ingin berpegang pada strategi ini untuk waktu yang lama. Karena ekuivalen posisi panjang dan pendek, Anda pada dasarnya tidak takut dengan tingkat pendanaan 8h. Dalam jangka panjang, tingkat kemenangan relatif tinggi. Tapi saya juga khawatir bahwa altcoin saat ini berada di bagian bawah, dan mungkin kehabisan tren kenaikan dan menyebabkan kerugian dari strategi ini.

Strategi kedua menggunakan fitur regresi harga altcoin, yang naik lebih dari indeks dan memiliki probabilitas tinggi untuk jatuh kembali. Namun, itu dapat mengumpulkan terlalu banyak posisi dalam satu mata uang. Jika mata uang tertentu benar-benar tidak jatuh kembali, itu akan menyebabkan kerugian besar.

Karena waktu awal yang berbeda dari strategi dan parameter spesifik, dampak dari orang-orang yang menggunakan strategi ini untuk waktu yang lama seharusnya tidak besar.

Singkatnya, tidak ada strategi yang sempurna, hanya sikap yang benar terhadap strategi, pada akhirnya tergantung pada pemahaman pengguna tentang risiko dan penilaian masa depan.

Berkaitan

Lebih banyak