Strategi panjang dan pendek penunjuk RSI
ChaoZhang
Gambaran keseluruhan
Strategi ini berdasarkan indeks relatif kuat lemah (RSI) yang dinilai, apabila RSI lebih tinggi daripada seting batas atas dan lebih banyak apabila RSI lebih rendah daripada seting batas bawah, adalah strategi perdagangan RSI yang tipikal. Strategi ini mempunyai fungsi seperti pengoptimuman parameter, strategi hentikan kerugian, dan lain-lain.
Prinsip Strategi
Logik utama strategi ini ialah:
- Mengira nilai RSI
- Tetapkan RSI atas dan bawah
- Apabila RSI naik, anda boleh masuk tanpa melihat.
- RSI di bawah batas bawah, lihat lebih lanjut
- Tetapkan keadaan hentikan dan hentikan
- Apabila RSI memasuki semula selang atau mencetuskan keadaan stop loss
Indikator RSI dapat menunjukkan bahawa pasaran berada dalam keadaan overbought atau oversold. Apabila RSI lebih tinggi daripada 70, ia dianggap sebagai overbought, dan apabila RSI lebih rendah daripada 30, ia dianggap sebagai oversold. Strategi perdagangan adalah berdasarkan keadaan RSI yang lebih baik untuk menentukan apakah ia akan menetapkan kedudukan kosong atau posisi berganda.
Strategi ini menggunakan logik klasik indikator RSI, berdasarkan nilai RSI dan hubungan antara had atas dan bawah yang ditetapkan untuk menentukan arah kedudukan. Strategi ini juga mempunyai parameter yang boleh disesuaikan, yang dapat mengoptimumkan had atas dan bawah RSI, stop loss, dan sebagainya, untuk menyesuaikan diri dengan perubahan pasaran.
Kelebihan Strategik
- Menggunakan RSI untuk menilai keadaan pasaran yang terlalu terlampau
- RSI berdasarkan teori yang diterima secara meluas
- Parameter strategi boleh disesuaikan untuk menyesuaikan diri dengan varieti dan keadaan pasaran yang berbeza
- Mekanisme Hentikan Kerosakan Bersepadu untuk Mengendalikan Risiko
Risiko strategik dan tindak balas
- Kemungkinan RSI memberi isyarat palsu yang menyebabkan kerugian yang tidak perlu
- Perlu terus mengoptimumkan RSI parameter
- Kemalangan yang disebabkan oleh gempa berkemungkinan disebabkan oleh Frequent.
Tindakan balas:
- Memastikan pengesahan pelbagai faktor dalam kombinasi dengan petunjuk lain untuk mengelakkan isyarat palsu
- Julat parameter RSI yang dioptimumkan mengikut ciri-ciri pelbagai jenis
- Menyesuaikan kedudukan hentian untuk mengurangkan risiko pegangan
Arah pengoptimuman strategi
Strategi ini boleh diperluaskan dan dioptimumkan dalam beberapa aspek:
Menggunakan pembelajaran mesin untuk mengoptimumkan rentang parameter RSI secara automatik
Meningkatkan pengesahan transaksi untuk mengelakkan penembusan palsu
Memperkuat pengesahan pelbagai faktor dengan penunjuk seperti Moving Average
Menetapkan strategi berhenti beradaptasi, menyesuaikan stop loss mengikut turun naik pasaran
Mengkaji perubahan dalam jumlah transaksi untuk menilai aliran masuk dan keluar wang
Menggabungkan strategi lain yang tidak relevan untuk mengurangkan penarikan diri secara keseluruhan
ringkaskan
Strategi ini menggunakan indikator RSI untuk menilai overbought dan oversold, merupakan strategi pembalikan yang mudah dan praktikal. Strategi ini boleh menyesuaikan parameter mengikut perubahan pasaran, tetapi juga boleh diperluaskan dan dioptimumkan dalam pelbagai dimensi. Dengan pengoptimuman parameter, pengesahan pelbagai faktor, dan penangguhan kendiri, strategi ini dapat dibuat lebih stabil dan boleh dipercayai.
/*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)