RSI Двухполосная линия колебаний Долгая и короткая двунаправленная стратегия торговли

Автор:Чао Чжан, Дата: 2023-10-25 11:57:46
Тэги:

Обзор

Двухнаправленная стратегия торговли длинной и короткой колебательной линией RSI представляет собой двунаправленную торговую стратегию, использующую индикатор RSI. Она реализует эффективное двунаправленное открытие и закрытие позиций с помощью принципов перекупленности и перепроданности RSI в сочетании с двунаправленными настройками и движущимися средними торговыми сигналами.

Логика стратегии

Стратегия в основном принимает торговые решения на основе принципов перекупленности и перепроданности индикатора RSI. Сначала она рассчитывает значение RSI vrsi, а также верхний рельс sn и нижний рельс ln двойных рельсов. Длинный сигнал генерируется, когда значение RSI пересекается ниже нижнего рельса ln, а короткий сигнал генерируется, когда значение RSI пересекается выше верхнего рельса sn.

Стратегия также обнаруживает подъем и падение свечей для дальнейшего генерирования длинных и коротких сигналов. В частности, длинный сигнал longLocic генерируется, когда свеча выходит вверх, и короткий сигнал shortLogic генерируется, когда свеча выходит вниз. Кроме того, стратегия предоставляет переключатели параметров для длинного, короткого или обратного сигналов.

После генерации длинных и коротких сигналов стратегия будет подсчитывать количество сигналов для контроля количества открытий. Различные правила пирамиды могут быть установлены через параметры. Условия закрытия позиции включают в себя получение прибыли, стоп-лосс, стоп-лосс и т. Д., С настраиваемыми процентными показателями прибыли и убытка.

В целом, стратегия включает в себя индикаторы RSI, скользящие средние кроссоверы, статистические пирамиды, стоп-прибыль и стоп-затраты и другие технические средства для достижения автоматизированной длинной и короткой двусторонней торговли.

Преимущества стратегии

Использовать принципы перекупления и перепродажи РСИ для установления длинных и коротких позиций на разумных уровнях.
Двойные рельсы предотвращают ошибочные сигналы. Верхняя рельса предотвращает преждевременное закрытие длинных позиций, а нижняя рельса предотвращает преждевременное закрытие коротких позиций.
Движущиеся торговые сигналы фильтруют ложные прорывы. Сигналы генерируются только тогда, когда цена пробивается через движущуюся среднюю, избегая ложных сигналов.
Считайте сигналы и время пирамиды, чтобы контролировать риски.
Процентные показатели прибыли и убытков, поддающиеся регулированию, для контроля прибыльности и риска.
Остановите убытки, чтобы еще больше закрепить прибыль.
Идите только длинные, короткие или обратные сигналы, чтобы адаптироваться к различным рыночным условиям.
Автоматизированная торговая система снижает затраты на ручную операцию.

Риски стратегии

Существует риск неудачного отмены РСИ. РСИ, входящий в зоны перекупленности или перепроданности, не обязательно отменяется.
Неправильные настройки могут привести к преждевременному снятию стоп-лосса или прибыли.
Неправильные параметры индикаторов негативно влияют на эффективность стратегии.
Одновременное запускание нескольких условий представляет собой риск пропущенных сделок.
Автоматизированные торговые системы имеют аномальные риски ошибок.

Для решения вышеуказанных рисков параметры могут быть оптимизированы, стратегии остановки прибыли и убытков могут быть скорректированы, фильтры ликвидности могут быть добавлены, логика сигналов может быть улучшена и мониторинг исключений может быть увеличен.

Руководство по оптимизации

Оптимизация параметров испытания параметров RSI на разных временных отрезках.
Проверьте различные настройки процента получения прибыли и стоп-лосса.
Добавьте фильтры объема или рентабельности, чтобы избежать недостаточной ликвидности.
Оптимизировать логику сигнала и улучшить пересечение скользящей средней.
Обратное тестирование в течение нескольких периодов времени для проверки стабильности.
Подумайте о добавлении других показателей для улучшения качества сигнала.
Включите стратегии размещения позиций.
Добавьте обработку исключений и мониторинг ошибок.
Оптимизируйте алгоритмы автоматической остановки.
Подумайте о включении машинного обучения для улучшения стратегии.

Резюме

Стратегия двойной рельсовой колебательной линии длинной и короткой двунаправленной торговли интегрирует индикаторы RSI, статистические принципы открытия и остановки потерь и другие технические инструменты для достижения автоматизированной двунаправленной торговли. Стратегия очень настраиваема для пользователей для адаптации параметров к различным рыночным условиям. Также есть возможности для улучшения с помощью оптимизации параметров, управления рисками, логики сигналов и т. Д. В целом она обеспечивает эффективное количественное торговое решение.

/*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)

Больше