RSI Garis osilasi dua rel Strategi perdagangan dua arah panjang dan pendek

Penulis:ChaoZhang, Tanggal: 2023-10-25 11:57:46
Tag:

Gambaran umum

RSI Dual-rail Oscillation Line Long and Short Bi-directional Trading Strategy adalah strategi perdagangan bidirectional yang menggunakan indikator RSI. Ini menerapkan pembukaan dan penutupan posisi bidirectional yang efisien melalui prinsip overbought dan oversold RSI, dikombinasikan dengan pengaturan dual-rail dan sinyal perdagangan moving average.

Logika Strategi

Strategi ini terutama membuat keputusan perdagangan berdasarkan prinsip overbought dan oversold dari indikator RSI. Pertama-tama menghitung nilai RSI vrsi, serta rel atas sn dan rel bawah ln dari rel ganda. Sinyal panjang dihasilkan ketika nilai RSI melintasi rel bawah ln, dan sinyal pendek dihasilkan ketika nilai RSI melintasi rel atas sn.

Strategi ini juga mendeteksi kenaikan dan penurunan candlesticks untuk lebih menghasilkan sinyal panjang dan pendek. Secara khusus, sinyal panjang longLocic dihasilkan ketika candlestick pecah ke atas, dan sinyal pendek shortLogic dihasilkan ketika candlestick pecah ke bawah. Selain itu, strategi menyediakan switch parameter untuk pergi panjang saja, pendek saja, atau sinyal terbalik.

Setelah menghasilkan sinyal panjang dan pendek, strategi akan menghitung jumlah sinyal untuk mengontrol jumlah pembukaan. Aturan piramida yang berbeda dapat ditetapkan melalui parameter. Kondisi penutupan posisi termasuk mengambil keuntungan, stop loss, trailing stop loss, dll, dengan persentase keuntungan dan kerugian yang dapat disesuaikan.

Singkatnya, strategi ini mengintegrasikan indikator RSI, crossover rata-rata bergerak, piramida statistik, stop profit dan stop loss dan sarana teknis lainnya untuk mencapai perdagangan dua arah panjang dan pendek otomatis.

Keuntungan dari Strategi

Menggunakan prinsip overbought dan oversold dari RSI untuk menetapkan posisi panjang dan pendek pada tingkat yang wajar.
Rel ganda mencegah sinyal yang salah. rel atas mencegah penutupan posisi panjang yang prematur, sementara rel bawah mencegah penutupan posisi pendek yang prematur.
Sinyal perdagangan rata-rata bergerak menyaring breakout palsu. Sinyal hanya dihasilkan ketika harga menembus rata-rata bergerak, menghindari sinyal palsu.
Hitung sinyal dan waktu piramida untuk mengendalikan risiko.
Persentase laba dan kerugian yang dapat disesuaikan untuk keuntungan dan risiko yang dapat dikontrol.
Stop loss untuk mengunci keuntungan lebih lanjut.
Hanya pergi panjang, hanya pendek atau sinyal terbalik untuk beradaptasi dengan lingkungan pasar yang berbeda.
Sistem perdagangan otomatis mengurangi biaya operasi manual.

Risiko dari Strategi

Risiko kegagalan pembalikan RSI ada. RSI memasuki zona overbought atau oversold tidak selalu berbalik.
Pengaturan yang tidak tepat dapat menyebabkan stop loss atau profit taking yang prematur.
Mengandalkan indikator teknis memiliki risiko optimasi. parameter indikator yang tidak tepat berdampak negatif pada kinerja strategi.
Pemberhentian beberapa kondisi secara bersamaan berisiko kehilangan perdagangan.
Sistem perdagangan otomatis memiliki risiko kesalahan yang tidak normal.

Untuk mengatasi risiko di atas, parameter dapat dioptimalkan, strategi stop profit and loss dapat disesuaikan, filter likuiditas dapat ditambahkan, logika sinyal dapat ditingkatkan, dan pemantauan pengecualian dapat ditingkatkan.

Arahan Optimasi

Optimasi parameter uji parameter RSI pada kerangka waktu yang berbeda.
Uji pengaturan persentase profit dan stop loss yang berbeda.
Tambahkan volume atau filter profitabilitas untuk menghindari likuiditas yang tidak cukup.
Mengoptimalkan logika sinyal dan meningkatkan penyeberangan rata-rata bergerak.
Backtest di beberapa periode waktu untuk memverifikasi stabilitas.
Pertimbangkan untuk menambahkan indikator lain untuk meningkatkan kualitas sinyal.
Sertakan strategi ukuran posisi.
Tambahkan penanganan pengecualian dan pemantauan kesalahan
Mengoptimalkan algoritma otomatis trailing stop.
Pertimbangkan untuk menggabungkan pembelajaran mesin untuk meningkatkan strategi.

Ringkasan

RSI Dual-rail Oscillation Line Long dan Short Bi-directional Trading Strategy mengintegrasikan indikator RSI, prinsip pembukaan dan stop loss statistik dan alat teknis lainnya untuk mencapai perdagangan bi-directional otomatis. Strategi ini sangat dapat disesuaikan bagi pengguna untuk menyesuaikan parameter dengan lingkungan pasar yang berbeda. Ada juga ruang untuk perbaikan melalui pengoptimalan parameter, manajemen risiko, logika sinyal, dll. Secara keseluruhan, ini memberikan solusi perdagangan kuantitatif yang efisien.

/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
// Learn more about Autoview and how you can automate strategies like this one here: https://autoview.with.pink/
// strategy("Autoview Build-a-bot - 5m chart", "Strategy", overlay=true, pyramiding=2000, default_qty_value=10000)
// study("Autoview Build-a-bot", "Alerts")

///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////

//* https://www.tradingview.com/script/eCC1cvxQ-Backtesting-Period-Selector-Component *//
//* https://www.tradingview.com/u/pbergden/ *//
//* Modifications made *//

testStartYear = input(1, "Backtest Start Year") 
testStartMonth = input(11, "Backtest Start Month")
testStartDay = input(10, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(77777777, "Backtest Stop Year")
testStopMonth = input(11, "Backtest Stop Month")
testStopDay = input(15, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

testPeriod() => true

/////////////////////////////////////
//* Put your strategy logic below *//
/////////////////////////////////////
RSIlength = input(1,title="RSI Period Length") 
price = close
vrsi = (rsi(price, RSIlength))
src = close
len = input(2, 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(12)
sn = 100 - rsin
ln = 0 + rsin

// Put your long and short rules here
longLocic = crossunder(rsi, ln)
shortLogic = crossover(rsi, sn)

//////////////////////////
//* Strategy Component *//
//////////////////////////

isLong = input(true, "Longs Only")
isShort = input(false, "Shorts Only")
isFlip = input(false, "Flip the Opens")

long = longLocic
short = shortLogic

if isFlip
    long := shortLogic
    short := longLocic
else
    long := longLocic
    short := shortLogic

if isLong
    long := long
    short := na

if isShort
    long := na
    short := short
    
////////////////////////////////
//======[ Signal Count ]======//
////////////////////////////////

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

//////////////////////////////
//======[ Pyramiding ]======//
//////////////////////////////

pyrl = input(2, "Pyramiding less than") // If your count is less than this number
pyre = input(1, "Pyramiding equal to") // If your count is equal to this number
pyrg = input(1000000, "Pyramiding greater than") // If your count is greater than this number

longCondition = long and sectionLongs <= pyrl or long and sectionLongs >= pyrg or long and sectionLongs == pyre ? 1 : 0 and vrsi < 20
shortCondition = short and sectionShorts <= pyrl or short and sectionShorts >= pyrg or short and sectionShorts == pyre ? 1 : 0

////////////////////////////////
//======[ Entry Prices ]======//
////////////////////////////////

last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])

////////////////////////////////////
//======[ Open Order Count ]======//
////////////////////////////////////

sectionLongConditions = 0
sectionLongConditions := nz(sectionLongConditions[1])
sectionShortConditions = 0
sectionShortConditions := nz(sectionShortConditions[1])

if longCondition
    sectionLongConditions := sectionLongConditions + 1
    sectionShortConditions := 0

if shortCondition
    sectionLongConditions := 0
    sectionShortConditions := sectionShortConditions + 1
    
///////////////////////////////////////////////
//======[ Position Check (long/short) ]======//
///////////////////////////////////////////////

last_longCondition = na
last_shortCondition = na
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])

in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition

/////////////////////////////////////
//======[ Position Averages ]======//
/////////////////////////////////////

totalLongs = 0.0
totalLongs := nz(totalLongs[1])
totalShorts = 0.0
totalShorts := nz(totalShorts[1])
averageLongs = 0.0
averageLongs := nz(averageLongs[1])
averageShorts = 0.0
averageShorts := nz(averageShorts[1]) 

if longCondition
    totalLongs := totalLongs + last_open_longCondition
    totalShorts := 0.0

if shortCondition
    totalLongs := 0.0
    totalShorts := totalShorts + last_open_shortCondition

averageLongs := totalLongs / sectionLongConditions
averageShorts := totalShorts / sectionShortConditions

/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////

isTS = input(false, "Trailing Stop")
tsi = input(100, "Activate Trailing Stop Price (%). Divided by 100 (1 = 0.01%)") / 100 
ts = input(100, "Trailing Stop (%). Divided by 100 (1 = 0.01%)") / 100

last_high = na
last_low = na
last_high_short = na
last_low_short = na
last_high := not in_longCondition ? na : in_longCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_high_short := not in_shortCondition ? na : in_shortCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_shortCondition ? na : in_shortCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
last_low_short := not in_longCondition ? na : in_longCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

long_ts = isTS and not na(last_high) and low <= last_high - last_high / 100 * ts and longCondition == 0 and last_high >= averageLongs + averageLongs / 100 * tsi
short_ts = isTS and not na(last_low) and high >= last_low + last_low / 100 * ts and shortCondition == 0 and last_low <= averageShorts - averageShorts/ 100 * tsi

///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////

isTP = input(true, "Take Profit")
tp = input(125, "Take Profit (%). Divided by 100 (1 = 0.01%)") / 100
long_tp = isTP and close > averageLongs + averageLongs / 100 * tp and not longCondition
short_tp = isTP and close < averageShorts - averageShorts / 100 * tp and not shortCondition

/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////

isSL = input(true, "Stop Loss")
sl = input(140, "Stop Loss (%). Divided by 100 (1 = 0.01%)") / 100
long_sl = isSL and close < averageLongs - averageLongs / 100 * sl and longCondition == 0
short_sl = isSL and close > averageShorts + averageShorts / 100 * sl and shortCondition == 0

/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////

longClose = long_tp or long_sl or long_ts ? 1 : 0
shortClose = short_tp or short_sl or short_ts ? 1: 0

///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////

longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? purple : long_sl ? maroon : long_ts ? blue : longCloseCol[1]
shortCloseCol := short_tp ? purple : short_sl ? maroon : short_ts ? blue : shortCloseCol[1]
tpColor = isTP and in_longCondition ? purple : isTP and in_shortCondition ? purple : white
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : white

//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////

plot(isTS and in_longCondition ? averageLongs + averageLongs / 100 * tsi : na, "Long Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_longCondition and last_high >= averageLongs +  averageLongs / 100 * tsi ? last_high - last_high / 100 * ts : na, "Long Trailing", fuchsia, style=2, linewidth=3)
plot(isTS and in_shortCondition ? averageShorts - averageShorts/ 100 * tsi : na, "Short Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_shortCondition and last_low <= averageShorts - averageShorts/ 100 * tsi ? last_low + last_low / 100 * ts : na, "Short Trailing", fuchsia, style=2, linewidth=3)
plot(isTP and in_longCondition and last_high < averageLongs + averageLongs / 100 * tp ? averageLongs + averageLongs / 100 * tp : na, "Long TP", tpColor, style=3, linewidth=2)
plot(isTP and in_shortCondition and last_low > averageShorts - averageShorts / 100 * tp ? averageShorts - averageShorts / 100 * tp : na, "Short TP", tpColor, style=3, linewidth=2)
plot(isSL and in_longCondition and last_low_short > averageLongs - averageLongs / 100 * sl ? averageLongs - averageLongs / 100 * sl : na, "Long SL", slColor, style=3, linewidth=2)
plot(isSL and in_shortCondition and last_high_short < averageShorts + averageShorts / 100 * sl ? averageShorts + averageShorts / 100 * sl : na, "Short SL", slColor, style=3, linewidth=2)

///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////

// plot(longCondition, "Long", green)
// plot(shortCondition, "Short", red)
// plot(longClose, "Long Close", longCloseCol)
// plot(shortClose, "Short Close", shortCloseCol)

///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////

if longClose or not in_longCondition
    averageLongs := 0
    totalLongs := 0.0
    sectionLongs := 0
    sectionLongConditions := 0

if shortClose or not in_shortCondition
    averageShorts := 0
    totalShorts := 0.0
    sectionShorts := 0
    sectionShortConditions := 0

////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////

if testPeriod()
    strategy.entry("Long", 1, when=longCondition)
    strategy.entry("Short", 0,  when=shortCondition)
    strategy.close("Long", when=longClose)
    strategy.close("Short", when=shortClose)

Lebih banyak

2019 FMZ - Semua hak dilindungi