Strategi panjang dan pendek indikator RSI
ChaoZhang
Ringkasan
Strategi ini didasarkan pada indikator kekuatan relatif (RSI) yang dinilai. Jika RSI lebih tinggi dari batas atas yang ditetapkan, maka Anda akan melakukan shorting, dan jika RSI lebih rendah dari batas bawah, maka Anda akan melakukan overtrading. Strategi ini merupakan strategi perdagangan RSI yang khas.
Prinsip Strategi
Logika inti dari strategi ini adalah:
- Perhitungan RSI
- Setting RSI upper and lower limits (Menetapkan batas atas dan bawah RSI)
- RSI di atas batas waktu, melihat ke bawah masuk
- RSI di bawah batas bawah, lihat lebih banyak entri
- Tetapkan Stop Loss Kondisi
- RSI melonggarkan posisi saat kembali ke interval atau memicu kondisi stop loss
Indikator RSI dapat menunjukkan apakah pasar berada dalam keadaan overbought atau oversold. Ketika RSI lebih tinggi dari 70, itu dianggap sebagai overbought, dan ketika RSI lebih rendah dari 30, itu dianggap sebagai oversold. Strategi perdagangan adalah berdasarkan kondisi RSI overbought dan oversold untuk menentukan apakah untuk membangun posisi kosong atau posisi multihead.
Strategi ini menggunakan logika klasik dari indikator RSI untuk menentukan arah posisi berdasarkan hubungan antara nilai RSI dan batas atas dan bawah yang telah ditentukan. Selain itu, strategi ini memiliki parameter yang dapat disesuaikan yang dapat mengoptimalkan batas atas dan bawah RSI, stop loss, dan sebagainya untuk menyesuaikan diri dengan perubahan pasar.
Keunggulan Strategis
- Menggunakan indikator RSI dapat secara efektif menilai kondisi pasar overbought dan oversold
- RSI didasarkan pada teori yang diterima secara luas
- Parameter strategi dapat disesuaikan dengan varietas dan kondisi pasar yang berbeda
- Integrasi Stop Loss Mechanism untuk Mengontrol Risiko
Risiko Strategis dan Tanggapan
- Kemungkinan RSI mengirimkan sinyal palsu yang menyebabkan kerugian yang tidak perlu
- Perlu terus mengoptimalkan rentang parameter RSI
- Kecelakaan yang disebabkan oleh gempa berkemungkinan disebabkan oleh frequent
Tindakan penanggulangan:
- Identifikasi multi-faktor dalam kombinasi dengan indikator lain untuk menghindari sinyal palsu
- RSI Optimasi Rentang Parameter Berdasarkan Karakteristik Berbagai Varietas
- Mengatur posisi stop loss untuk mengurangi risiko underlay
Arah optimasi strategi
Strategi ini dapat diperluas dan dioptimalkan dalam beberapa hal:
Menggunakan pembelajaran mesin untuk mengoptimalkan interval parameter RSI secara otomatis
Meningkatkan Konfirmasi Transaksi dan Menghindari Penembusan Palsu
Multi-factor verifikasi dengan indikator seperti Moving Average
Menetapkan strategi stop loss adaptif dan menyesuaikan stop loss sesuai dengan fluktuasi pasar
Studi perubahan volume transaksi untuk menilai arus masuk dan keluar dana
Kombinasi dengan strategi lain yang tidak relevan untuk mengurangi overall withdrawal
Meringkaskan
Strategi ini menggunakan indikator RSI untuk menilai overbought dan oversold, dan merupakan strategi pembalikan yang sederhana dan praktis. Strategi ini dapat menyesuaikan parameter sesuai dengan perubahan pasar, atau dapat diperluas dan dioptimalkan dalam berbagai dimensi. Dengan perbaikan seperti pengoptimalan parameter, verifikasi multi-faktor, dan stop loss, strategi dapat dibuat lebih stabil dan dapat diandalkan.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("4All V3", shorttitle="Strategy", overlay=true)
/////////////// Component Code Start ///////////////
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
src = close
len = input(4, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsin = input(5)
sn = 100 - rsin
ln = 0 + rsin
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000
pyr = input(1, "Pyramiding")
short = crossover(rsi, sn)
long = crossunder(rsi, ln)
totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])
totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr
last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = na
last_open_short_signal = na
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = na
last_short_signal = na
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = na
last_low = na
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal
long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)
long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)
leverage = input(1, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call
if testPeriod()
strategy.entry("Long", strategy.long, when=longCondition)
strategy.entry("Short", strategy.short, when=shortCondition)
strategy.close("Long", when=long_call_signal)
strategy.close("Short", when=short_call_signal)
strategy.close("Long", when=long_tp)
strategy.close("Short", when=short_tp)
strategy.close("Long", when=long_sl)
strategy.close("Short", when=short_sl)
strategy.close("Long", when=long_ts)
strategy.close("Short", when=short_ts)