ianzeng123
2
Подписаться
319
Подписчики
Обзор
Стратегия представляет собой комплексную торговую систему, объединяющую Gaussian channel filter и случайный RSI. Торговые возможности определяются с помощью изменения направления Gaussian channel и ценового положения в сочетании с сигналом перекупа и перепродажи в случайном RSI. Стратегия использует сложные математические модели для построения адаптивных каналов, которые эффективно фильтруют рыночный шум и улавливают важные ценовые изменения.
Стратегический принцип
Основная логика стратегии основана на следующих ключевых компонентах:
- Вычисление канала Гауста: обрабатывание данных о ценах HLC3 с использованием многодольного канала Гауста для создания адаптивного канала. Оптимизация эффекта фильтрации с помощью параметров бета и альфа, а также возможность уменьшения задержки.
- Настройка ширины канала: динамическая настройка ширины канала на основе реальной амплитуды (TR), используя 1.414 в качестве коэффициента по умолчанию.
- Случайный сигнал RSI: в сочетании с 14 циклами RSI и случайным индикатором, который дает сигнал выше 80 или ниже 20.
- Условия для входа: необходимо одновременно удовлетворить три условия: повышение Gauss Channel, прорыв цены вверх, случайный сигнал RSI.
- Логика выхода: Прямая позиция, когда цена падает вверх по Гаусскому каналу.
Стратегические преимущества
- Надежность сигналов: механизм подтверждения множественных показателей значительно повышает надежность торговых сигналов.
- Самостоятельная адаптация: канал Гауса может автоматически корректировать ширину канала в зависимости от рыночных колебаний.
- Фильтрация шума: фильтры Gauss эффективно снижают влияние рынка шума.
- Высокая гибкость: предоставляется множество регулируемых параметров, включая циклы каналов, количество полюсов и параметры RSI.
- Визуальная интуиция: Интуитивно показывает направление тренда и торговые сигналы с помощью изменения цвета.
Стратегический риск
- Чувствительность параметров: количество точек в канале Гауста и настройка цикла выборки оказывают большое влияние на эффективность стратегии.
- Риск отставания: Несмотря на то, что предлагаются варианты уменьшения отставания, сам показатель остается отсталым.
- Риск ложного прорыва: возможны частые ложные сигналы прорыва на криптовалютных рынках.
- Недостаточное управление капиталом: отсутствие подробного механизма управления позициями в текущей версии.
Направление оптимизации стратегии
- Идентификация рыночных условий: добавление показателей интенсивности тренда, корректировка параметров стратегии в различных рыночных условиях.
- Динамическая оптимизация параметров: параметры Gaussian Channel автоматически корректируются в зависимости от волатильности рынка.
- Усовершенствование управления позициями: внедрение динамической системы управления позициями на основе волатильности.
- Усиленный механизм выхода: увеличение мобильного стоп-лосса и частично прибыльный механизм закрытия.
- Оптимизация временных рамок: проверка сигналов на нескольких временных рамках, повышение стабильности торгов.
Подвести итог
Эта стратегия, в сочетании с фильтром Gaussian Channel и случайным RSI, создает торговую систему с высокой самовоспроизводительностью. Математическая основа Gaussian Channel гарантирует гладкость и надежность сигналов, а сочетание с случайным RSI еще больше повышает точность времени входа в рынок. Основные преимущества стратегии заключаются в ее эффективном фильтрации рыночного шума и точном понимании тенденций, но при этом необходимо обратить внимание на вопросы цифровой оптимизации и управления рисками.
Исходный код стратегии
/*backtest
start: 2024-02-22 00:00:00
end: 2025-02-19 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"SOL_USDT"}]
*/
//@version=5
strategy(title="Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, slippage=0, fill_orders_on_standard_ohlc=true)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Filter Functions (Must be declared first)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
_f := math.pow(_a, _i) * nz(_s) + _i * _x * nz(_f[1]) - (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ? _m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ? _m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ? _m9 * math.pow(_x, 9) * nz(_f[9]) : 0)
f_pole(_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.0
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 : _i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 : _i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Calculations
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)
src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr
[filterMain, filter1] = f_pole(alpha, srcData, poles)
[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)
finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain
finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain
hband = finalFilter + finalTR * mult
lband = finalFilter - finalTR * mult
// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Trading Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20
longCondition = gaussianGreen and priceAbove and stochCondition
exitCondition = ta.crossunder(close, hband)
strategy.entry("Long", strategy.long, when=longCondition)
strategy.close("Long", when=exitCondition)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Visuals
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")