ianzeng123
2
konzentrieren Sie sich auf
319
Anhänger
Überblick
Die Strategie ist ein integriertes Handelssystem, das einen Gauss-Kanalfilter mit einem Zufalls-RSI-Indikator kombiniert. Die Handelsmöglichkeiten werden durch die Richtungsänderungen und die Preisposition des Gauss-Kanals in Verbindung mit dem Überkauf-Überverkauf-Signal des Zufalls-RSI bestimmt. Die Strategie verwendet komplexe mathematische Modelle, um einen Anpassungskanal zu erstellen, der Marktlärm effektiv filtert und wichtige Preisänderungen erfasst.
Strategieprinzip
Die Kernlogik der Strategie basiert auf den folgenden Schlüsselkomponenten:
- Gauss-Kanal-Berechnung: Verarbeitung von HLC3-Preisdaten mit einem Goss-Filter mit mehreren Goss-Filtern, um einen adaptiven Kanal zu erstellen. Optimierung der Filterwirkung durch Beta- und Alpha-Parameter und optional Verringerung der Verzögerung
- Kanalbreiten-Anpassung: Die Kanalbreite wird dynamisch an die tatsächliche Bandbreite angepasst, wobei 1.414 als Standardmenge verwendet wird.
- Zufälliges RSI-Signal: In Kombination mit dem 14-Zyklus-RSI und einem Zufälligkeitsindikator erzeugt es ein Signal über 80 oder unter 20.
- Eintrittsvoraussetzungen: Die drei Bedingungen müssen gleichzeitig erfüllt sein: Aufwärtsgang des Gauss-Kanals, Preisbruch auf der Strecke und Zufallsschalter RSI.
- Exit-Logik: Platziert, wenn der Preis unterhalb des Gauss-Kanals aufgeht.
Strategische Vorteile
- Signalzuverlässigkeit: Die Multi-Indicator-Bestätigungsmechanismen erhöhen die Zuverlässigkeit der Handelssignale erheblich.
- Anpassungsfähigkeit: Gauss-Kanal kann die Kanalbreite automatisch an Marktschwankungen anpassen.
- Lärmfilter: Die Gauss-Filter reduzieren die Auswirkungen von Marktlärm.
- Hohe Flexibilität: Eine Vielzahl an anpassbaren Parametern, einschließlich der Durchlaufzeit, der Anzahl der Polarpunkte und der RSI-Parameter.
- Visuelle Intuition: Intuitive Anzeige der Trendrichtung und der Handelssignale durch Farbänderungen.
Strategisches Risiko
- Parameter-Sensitivität: Die Anzahl der Gauss-Kanal-Punkte und die Einstellung des Sampling-Zyklus beeinflussen die Strategie-Performance.
- Rückstandsrisiko: Obwohl die Optionen zur Verringerung des Rückstands angeboten werden, ist der Indikator an sich etwas zurückgeblieben.
- Falsche Durchbruchgefahr: Häufige falsche Durchbruchsignale können in den OTC-Märkten auftreten
- Unzureichende Vermögensverwaltung: Die aktuelle Version fehlt an einem detaillierten Positionsverwaltungsmechanismus.
Richtung der Strategieoptimierung
- Identifizierung des Marktumfelds: Hinzufügen von Indikatoren für die Trendstärke und Anpassung der Strategieparameter an unterschiedliche Marktumgebungen.
- Dynamische Parameter-Optimierung: Die Parameter-Einstellungen des Gauss-Kanals werden automatisch an die Marktschwankungen angepasst.
- Positionsmanagement verbessert: Einführung eines dynamischen Positionsmanagementsystems, das auf Volatilität basiert.
- Erhöhung der Ausgangsmöglichkeiten: Erhöhung der mobilen Stop-Loss- und Teilgewinn-Knoten.
- Optimierung des Zeitrahmens: Signalüberprüfung über mehrere Zeitrahmen hinweg zur Steigerung der Handelsstabilität.
Zusammenfassen
Durch die Kombination von Gauss-Kanal-Filtern und Zufalls-RSI-Indikatoren entsteht ein Handelssystem mit hoher Adaptivität. Die mathematische Grundlage des Gauss-Kanals gewährleistet die Glattigkeit und Zuverlässigkeit der Signale, während die Kombination mit dem Zufalls-RSI die Genauigkeit der Einstiegsmomente weiter verbessert. Die Hauptvorteile der Strategie liegen in ihrer effektiven Filterung von Marktgeräuschen und der genauen Erfassung von Trends, wobei jedoch auch auf die Probleme der numerischen Optimierung und des Risikomanagements geachtet werden muss.
Strategiequellcode
/*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")