Strategi perdagangan pembalikan berdasarkan indikator RSI
ChaoZhang
Ringkasan
Strategi ini menggunakan indikator RSI untuk mengidentifikasi kondisi pasar di mana saham overbought dan oversold, membentuk dead fork dan shorting di zona overbought, dan membentuk gold fork dan oversold di zona oversold. Strategi ini merupakan strategi perdagangan berbalik berdasarkan indikator. Strategi ini dikombinasikan dengan trend tracking stop loss, stop loss tetap, dapat secara efektif mengendalikan risiko perdagangan.
Prinsip Strategi
Sinyal perdagangan strategi ini didasarkan pada indikator RSI. Sinyal RSI umumnya memiliki 30 sebagai garis oversold dan 70 sebagai garis overbought. Ketika melewati garis oversold di atas RSI, menghasilkan sinyal beli; Ketika melewati garis oversold di bawah RSI, menghasilkan sinyal jual.
Setelah masuk ke pasar, strategi ini menggunakan stop loss yang dilacak dengan persentase, dengan terus-menerus memperbarui harga tertinggi atau terendah, dan meninggalkan persentase tertentu sebagai stop loss. Selain itu, ada juga stop loss dengan jarak yang tetap, yang berhenti ketika mencapai target keuntungan atau kerugian maksimum. Kombinasi ini dapat mengontrol risiko perdagangan dengan baik.
Analisis Keunggulan
Strategi ini memiliki keuntungan sebagai berikut:
Menggunakan indikator RSI untuk menilai zona overbought dan oversold adalah teknik trading yang lebih matang yang dapat menangkap titik balik pasar dengan lebih akurat.
Dengan menggunakan metode Gold Fork Dead Fork, beberapa sinyal perdagangan yang berisik dapat disaring, sehingga transaksi lebih dapat diandalkan.
Kombinasi dengan trend tracking stop loss, Anda dapat memaksimalkan keuntungan terkunci, tetapi juga dapat menghentikan kerugian dengan cepat, mengurangi kerugian tunggal.
Stop loss jarak tetap juga dapat secara efektif mengendalikan risiko transaksi tunggal.
Secara keseluruhan, aturan strategi ini jelas, mudah dimengerti dan diterapkan, cocok untuk pemula dalam trading kuantitatif.
Analisis risiko
Strategi ini juga memiliki risiko sebagai berikut:
Indikator RSI mudah menghasilkan sinyal yang salah, kemungkinan besar akan terjadi ruptur bentuk teknis, yang dapat menyebabkan stop loss dipicu.
Stop loss jarak tetap, tidak dapat disesuaikan dengan tingkat fluktuasi pasar, mungkin akan berhenti terlalu dini atau memperluas stop loss.
Stop loss persentase hanya melacak titik tertinggi atau terendah harga, dan mungkin terlalu radikal sehingga tidak menguntungkan.
Risiko penyesuaian data retrospektif. Parameter strategi ini mungkin dioptimalkan untuk data historis, dan mungkin berkinerja buruk dalam aplikasi nyata.
Frekuensi transaksi mungkin terlalu tinggi, meningkatkan biaya transaksi dan risiko slippage.
Arah optimasi
Strategi ini dapat dioptimalkan dari beberapa arah:
Mengoptimalkan parameter RSI, mencari kombinasi parameter indikator terbaik, meningkatkan kualitas sinyal.
Menambahkan filter indikator lain, membentuk resonansi multi-indikator, meningkatkan akurasi sinyal.
Adaptive Stop Loss Mechanism (ASL) yang secara otomatis menyesuaikan stop loss sesuai dengan fluktuasi pasar
Meningkatkan frekuensi transaksi, mengurangi jumlah transaksi, dan mengurangi biaya transaksi.
Menambahkan modul pengelolaan dana, mengontrol volume transaksi tunggal, dan mengurangi kerugian tunggal.
Pengukuran ulang dilakukan dalam periode waktu yang lebih lama untuk memeriksa stabilitas parameter.
Meringkaskan
Strategi ini secara keseluruhan adalah strategi perdagangan terbalik yang khas, menggunakan indikator RSI untuk menentukan area overbought dan oversold, menghasilkan sinyal perdagangan dengan cara garpu gantung dan garpu gantung. Dan menggunakan stop loss yang mengikuti tren dan stop loss yang tetap untuk mengendalikan risiko. Strategi ini logisnya jelas, mudah diimplementasikan, dan cocok untuk belajar dan praktik pemula perdagangan kuantitatif.
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// LOVE JOY PEACE PATIENCE KINDNESS GOODNESS FAITHFULNESS GENTLENESS SELF-CONTROL
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// Author: © JoshuaMcGowan
// Taken from https://www.tradingview.com/script/GbZGYi6l-Adding-some-essential-components-to-a-prebuilt-RSI-strategy/
// Just updated to compile in version 4.
//@version=4
strategy("Adding some essential components to a prebuilt RSI 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(2100, "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=input.bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
// Replace RSI Component, Long/Short, and Long Signal/Short Signal conditions with your trade setup components.
///////////// RSI component /////////////
length = input( 14 )
overSold = input( 30 )
overBought = input( 70 )
price = close
vrsi = rsi(price, length)
notna = not na(vrsi)
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 100
tp = input(99999, "Take Profit") / 100
sl = input(99999, "Stop Loss") / 100
// Update this with your setup.
long = notna and crossover(vrsi, overSold)
short = notna and crossunder(vrsi, overBought)
last_long = 0
last_short = 0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
// Update this to reflect your setup.
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
float last_open_long_signal = 0
float last_open_short_signal = 0
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 = 0
last_short_signal = 0
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
float last_high = 0
float last_low = 0
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(200, "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=long_signal)
strategy.entry("Short", strategy.short, when=short_signal)
// plot(long_call, color=color.red)
// plot(short_call, color=color.green)
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)