Strategi Perdagangan Pembalikan Rata-rata Bergerak
ChaoZhang
Ringkasan
Strategi perdagangan regresi rata-rata adalah strategi perdagangan yang didasarkan pada seberapa jauh harga dari rata-rata. Strategi ini memanfaatkan karakteristik harga yang menyimpang dari rata-rata jangka pendek, untuk membangun posisi ketika harga secara signifikan di bawah atau di atas rata-rata, dan untuk melakukan pelepasan posisi ketika harga kembali ke rata-rata.
Prinsip Strategi
Strategi ini pertama-tama menghitung rata-rata bergerak untuk periode tertentu, yang mewakili tren harga jangka panjang. Kemudian, berdasarkan pada seberapa jauh harga dari rata-rata bergerak, waktu dan ukuran posisi ditentukan untuk membangun posisi.
Ketika harga berada di bawah rata-rata bergerak dalam proporsi tertentu, berarti harga menyimpang dari tren jangka panjang, dan pada saat itu, berdasarkan proporsi posisi tertentu, multi-order akan dibangun secara bertahap. Semakin jauh harga menyimpang, semakin besar posisi yang didirikan.
Demikian pula, ketika harga lebih tinggi dari rata-rata bergerak dalam proporsi tertentu, Anda membuat blanko. Ketika harga turun kembali ke rata-rata bergerak, Anda melunasi proporsi tersebut.
Analisis Keunggulan
Menggunakan kemampuan untuk mengidentifikasi tren rata-rata, mengikuti tren ekuilibrium jangka panjang dari harga saham, dan menangkap arah tren utama.
Dengan membangun posisi secara batch, mengurangi biaya membangun gudang, dan mendapatkan harga biaya yang lebih baik.
Menggunakan hambatan bertahap, dengan tingkat kemunduran yang berbeda, rata-rata memiliki peluang hambatan yang berbeda, mengurangi risiko.
Pengendalian posisi menggunakan saham tetap untuk menghindari kerugian tunggal yang terlalu besar.
Pengaturan parameter fleksibel, dapat disesuaikan dengan varietas yang berbeda untuk periode moving average atau rasio posisi.
Analisis risiko
Stop loss mungkin sering terjadi pada saat harga bergejolak. Stop loss dapat dilepaskan secara tepat, atau kondisi penyaringan lainnya dapat digunakan.
Saham yang kuat dapat langsung menerobos garis rata-rata untuk terus naik atau turun, tidak dapat kembali ke garis rata-rata berhenti. Dapat dikombinasikan dengan indikator tren untuk menilai tren yang kuat, mengurangi posisi.
Setting parameter yang tidak tepat dapat menyebabkan terlalu agresif posisi atau stop loss. Parameter harus diuji dengan hati-hati dan disesuaikan dengan pasar.
Biaya transaksi mungkin lebih tinggi jika transaksi sering, dan parameter optimasi faktor biaya harus dipertimbangkan.
Arah optimasi
Optimalkan siklus rata-rata bergerak untuk menyesuaikan dengan karakteristik varietas yang berbeda.
Mengoptimalkan rasio posisi, menyeimbangkan risiko dan keuntungan.
Menambahkan filter untuk indikator teknis lainnya untuk menghindari transaksi yang tidak perlu.
Dengan mengkombinasikan indikator volatilitas, rasio posisi disesuaikan dengan tingkat volatilitas pasar.
Untuk mengurangi risiko dan meningkatkan tingkat pengembalian.
Meringkaskan
Strategi equity return memanfaatkan sifat equity return saham, ketika harga menyimpang dari garis rata-rata bergerak untuk membangun posisi, ketika harga kembali berhenti, dapat secara efektif menangkap jangka panjang tren saham. Dengan parameter optimasi dan indikator filter, dapat beradaptasi dengan perubahan pasar, dengan asumsi pengendalian risiko untuk mendapatkan hasil yang lebih baik. Strategi ini mempertimbangkan trend tracking dan fokus pada pengendalian risiko, layak untuk penelitian dan aplikasi investor.
/*backtest
start: 2022-10-19 00:00:00
end: 2023-10-25 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("YJ Mean Reversion", overlay=true)
//Was designed firstly to work on an index like the S&P 500 , which over time tends to go up in value.
//Avoid trading too frequently (e.g. Daily, Weekly), to avoid getting eaten by fees.
//If you change the underlying asset, or time frame, tweaking the moving average may be necessary.
//Can work with a starting capital of just $1000, optimise the settings as necessary.
//Accepts floating point values for the amount of units to purchase (e.g. Bitcoin ).
//If price of units exceeds available capital, script will cancel the buy.
//Adjusted the input parameters to be more intuitive.
//input variables
movingAverage = input(title="Moving Average (bars)", type=input.integer, defval=28, minval=1, maxval=1000)
//riskPercentage = input(title="Amount to Risk (%)", type=input.integer, defval=1, minval=1, maxval=50)
deviation = input(title="Deviation Increment (%)", type=input.float, defval=5, minval=0.01, maxval=100) / 100
unitsLevel1 = input(title="Level 1 (units)", type=input.float, defval=1, minval=0.0001, maxval=10000)
unitsLevel2 = input(title="Level 2 (units)", type=input.float, defval=2, minval=0.0001, maxval=10000)
unitsLevel3 = input(title="Level 3 (units)", type=input.float, defval=4, minval=0.0001, maxval=10000)
unitsLevel4 = input(title="Level 4 (units)", type=input.float, defval=8, minval=0.0001, maxval=10000)
unitsLevel5 = input(title="Level 5 (units)", type=input.float, defval=16, minval=0.0001, maxval=10000)
//moving average and ma slope (use on weekly chart)
ma = sma(close, movingAverage)
//sl = ma > ma[4]
//units to buy
//amount = riskPercentage / 100 * (strategy.initial_capital + strategy.netprofit)
//units = floor(amount / close)
//mode 1
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (strategy.position_size < 10))
//strategy.order("sell", false, strategy.position_size, when = (close > 1.05 * ma) and (strategy.position_size > 0))
//mode 2
//strategy.order("buy", true, 1, when = close < 0.8 * ma)
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 3
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 4
//strategy.order("buy", true, 1, when = (close < 0.98 * ma) and (close > 0.96 * ma) and (sl))
//strategy.order("buy", true, 2, when = (close < 0.96 * ma) and (close > 0.94 * ma) and (sl))
//strategy.order("buy", true, 4, when = (close < 0.94 * ma) and (close > 0.92 * ma) and (sl))
//strategy.order("buy", true, 8, when = (close < 0.92 * ma) and (close > 0.90 * ma) and (sl))
//strategy.order("buy", true, 16, when = (close < 0.90 * ma) and (sl))
//strategy.order("sell", false, strategy.position_size, when = (close > 310) and (strategy.position_size > 0))
//mode 5
//strategy.order("buy", true, 1, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("buy", true, 2, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("buy", true, 4, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("buy", true, 8, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("buy", true, 16, when = (close < 0.75 * ma))
//strategy.order("sell", false, 1, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 2, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 4, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 8, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("sell", false, 16, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//mode 6
//strategy.order("B1", true, unitsLevel1 * units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, unitsLevel2 * units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, unitsLevel3 * units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, unitsLevel4 * units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, unitsLevel5 * units, when = (close < 0.75 * ma))
//strategy.order("S1", false, unitsLevel1 * units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, unitsLevel2 * units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, unitsLevel3 * units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, unitsLevel4 * units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, unitsLevel5 * units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//mode 7
//strategy.order("B1", true, units, when = (close < 0.95 * ma) and (close > 0.9 * ma))
//strategy.order("B2", true, units, when = (close < 0.9 * ma) and (close > 0.85 * ma))
//strategy.order("B3", true, units, when = (close < 0.85 * ma) and (close > 0.8 * ma))
//strategy.order("B4", true, units, when = (close < 0.8 * ma) and (close > 0.75 * ma))
//strategy.order("B5", true, units, when = (close < 0.75 * ma))
//strategy.order("S1", false, units, when = (close > 1.05 * ma) and (close < 1.1 * ma) and (strategy.position_size > 0))
//strategy.order("S2", false, units, when = (close > 1.1 * ma) and (close < 1.15 * ma) and (strategy.position_size > 0))
//strategy.order("S3", false, units, when = (close > 1.15 * ma) and (close < 1.2 * ma) and (strategy.position_size > 0))
//strategy.order("S4", false, units, when = (close > 1.2 * ma) and (close < 1.25 * ma) and (strategy.position_size > 0))
//strategy.order("S5", false, units, when = (close > 1.25 * ma) and (close < 1.3 * ma) and (strategy.position_size > 0))
//banding calculations
aH = 1.0 - deviation
aL = aH - deviation
bH = aL
bL = bH - deviation
cH = bL
cL = cH - deviation
dH = cL
dL = dH - deviation
eH = dL
strategy.initial_capital = 50000
//mode 8
strategy.order("B1", true, unitsLevel1, when = (close < aH * ma) and (close > aL * ma) and (unitsLevel1 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B2", true, unitsLevel2, when = (close < bH * ma) and (close > bL * ma) and (unitsLevel2 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B3", true, unitsLevel3, when = (close < cH * ma) and (close > cL * ma) and (unitsLevel3 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B4", true, unitsLevel4, when = (close < dH * ma) and (close > dL * ma) and (unitsLevel4 * close < (strategy.initial_capital + strategy.netprofit)))
strategy.order("B5", true, unitsLevel5, when = (close < eH * ma) and (unitsLevel5 * close < (strategy.initial_capital + strategy.netprofit)))
//banding calculations
fL = 1.0 + deviation
fH = fL + deviation
gL = fH
gH = gL + deviation
hL = gH
hH = hL + deviation
iL = hH
iH = iL + deviation
jL = iH
strategy.order("S1", false, unitsLevel1, when = (close > fL * ma) and (close < fH * ma) and (strategy.position_size > 0))
strategy.order("S2", false, unitsLevel2, when = (close > gL * ma) and (close < gH * ma) and (strategy.position_size > 0))
strategy.order("S3", false, unitsLevel3, when = (close > hL * ma) and (close < hH * ma) and (strategy.position_size > 0))
strategy.order("S4", false, unitsLevel4, when = (close > iL * ma) and (close < iH * ma) and (strategy.position_size > 0))
strategy.order("S5", false, unitsLevel5, when = (close > jL * ma) and (strategy.position_size > 0))
plot(ma, color=#666666, linewidth=5)