Mehrfachumkehrstrategie basierend auf dem Trenddurchschnitt
ChaoZhang
Überblick
Die Strategie berechnet mehrere Trendindikatoren und führt Kauf- und Verkaufshandlungen bei deren Umkehrung durch. Die wichtigsten Trendindikatoren sind TDI, TCF, TTF und TII. Die Strategie wählt in der Konfiguration, welcher der Indikatoren verwendet wird, um ein Handelssignal zu erzeugen.
Strategieprinzip
- ### TDI-Indikatoren
Der TDI-Indikator basiert auf dem Preisveränderungsmomentum und berechnet die Summierung und das Smoothing. Der TDI-Indikator wird durch Summierung und Smoothing aufgebaut.
- ### TCF-Indikatoren
Der TCF-Indikator berechnet die positive und negative Veränderung des Preises, um die Kräfte von Mehrköpfen und Leerköpfen zu beurteilen. Wenn die positive Veränderung größer ist als die negative Veränderung, werden die Bestände geklärt.
- ### TTF-Indikatoren
Der TTF-Indikator beurteilt Trends durch den Vergleich der Stärke von Höhen und Tiefen. Das Signal, dass mehr getan wird, ist das Durchschreiten von 100 auf dem TTF-Indikator, umgekehrt die Auflösung.
- ### TII-Indikatoren
Der TII-Indikator kombiniert die Durchschnittslinie und die Preisspanne, um eine Trendwende zu beurteilen. Er berücksichtigt sowohl kurzfristige als auch langfristige Trends. Ein Mehrsignal bedeutet, dass der TII-Indikator 80 erreicht hat, und ein Clearing bedeutet, dass er 80 erreicht hat.
Die Logik der Multi-Pac-Position: Wählen Sie die richtigen Handelssignale aus, basierend auf den vorgegebenen Kennzahlen.
Strategische Vorteile
Die Strategie kombiniert eine Vielzahl von gängigen Trend-Trading-Indikatoren, die sich flexibel an die Marktbedingungen anpassen können. Die konkreten Vorteile sind:
- Mit Hilfe von Trendwende-Signalen können Chancen für eine Trendwende erfasst werden.
- Verschiedene Kennzahlen können gezielt optimiert werden
- Eine umfangreiche Kombination von Indikatoren, die in Kombination verwendet werden können, um Signale zu bestätigen
Strategisches Risiko
Die Risiken der Strategie sind vor allem:
- Handelssignale, die von Trendindikatoren erzeugt werden, können falsch gemeldet werden, was zu Verlusten führt
- Ein einziger Indikator ist nicht in der Lage, Trends zu beurteilen und ist von Marktlärm beeinflusst.
- Falsch konfigurierte Indikator- und Handelsparameter können zu Marktverzerrungen und fehlerhaften Transaktionen führen
Die folgenden Maßnahmen können das Risiko verringern:
- Optimierung der Kennzahlenparameter, um die beste Kombination zu finden
- Kombinieren Sie mehrere Indicator-Signale zum Handel und verbessern Sie die Signalqualität
- Anpassung der Positionsmanagement-Strategie zur Kontrolle von Einzelschäden
Richtung der Strategieoptimierung
Diese Strategie kann in folgenden Bereichen optimiert werden:
- Testen von optimalen Kombinationen von Indikatoren und Parametern für verschiedene Marktzyklen
- Hinzufügen oder Entfernen von Kennzahlen, um die optimale Kombination zu finden
- Filterung von Handelssignalen, um falsche Signale zu entfernen
- Optimierung von Positionsmanagementstrategien, z. B. Wechselpositionen, Verfolgung von Stop-Losses
- Erhöhung der Machine-Learning-Bewertung, um die Signalqualität zu beurteilen
Zusammenfassen
Die Strategie kombiniert die Vorzüge mehrerer Trendwende-Indikatoren, optimiert durch die Konfiguration von Indikatoren und Parametern, kann an verschiedene Marktbedingungen angepasst werden, um an Trendwendepunkten zu handeln. Der Schlüssel ist, die optimale Kombination von Parametern und Indikatoren zu finden, während das Risiko kontrolliert wird. Durch kontinuierliche Optimierung und Verifizierung kann eine Strategie mit stabiler Alpha aufgebaut werden.
/*backtest
start: 2023-11-13 00:00:00
end: 2023-11-15 03:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
//
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © kruskakli
//
// Here is a collection of Trend Indicators as defined by M.H Pee and presented
// in various articles of the "STOCKS & COMMODITIES Magazine"
//
// The actual implementation of the indicators here are made by: everget
//
// I have gather them here so that they easily can be tested.
//
// My own test was made using 15 companies from the OMXS30 list
// during the time period of 2016-2018, and I only went LONG.
//
// The result was as follows:
//
// Average Std.Dev
// profit
// TDI 3.04% 5.97
// TTF 1.22%. 5.73
// TII 1.07% 6.2
// TCF 0.32% 2.68
//
strategy("M.H Pee indicators", overlay=true)
use = input(defval="TDI", title="Use Indicator", type=input.string,
options=["TDI","TCF","TTF","TII"])
src = close
//
// TDI
//
length = input(title="Length", type=input.integer, defval=20)
mom = change(close, length)
tdi = abs(sum(mom, length)) - sum(abs(mom), length * 2) + sum(abs(mom), length)
// Direction Indicator
tdiDirection = sum(mom, length)
tdiLong = crossover(tdiDirection, tdi)
tdiXLong = crossunder(tdiDirection, tdi)
//
// TCF
//
tcflength = input(title="Length", type=input.integer, defval=35)
plusChange(src) =>
change_1 = change(src)
change(src) > 0 ? change_1 : 0.0
minusChange(src) =>
change_1 = change(src)
change(src) > 0 ? 0.0 : -change_1
plusCF = 0.0
plusChange__1 = plusChange(src)
plusCF := plusChange(src) == 0 ? 0.0 : plusChange__1 + nz(plusCF[1])
minusCF = 0.0
minusChange__1 = minusChange(src)
minusCF := minusChange(src) == 0 ? 0.0 : minusChange__1 + nz(minusCF[1])
plusTCF = sum(plusChange(src) - minusCF, tcflength)
minusTCF = sum(minusChange(src) - plusCF, tcflength)
tcfLong = plusTCF > 0
tcfXLong = plusTCF < 0
//
// TTF
//
ttflength = input(title="Lookback Length", type=input.integer, defval=15)
hh = highest(length)
ll = lowest(length)
buyPower = hh - nz(ll[length])
sellPower = nz(hh[length]) - ll
ttf = 200 * (buyPower - sellPower) / (buyPower + sellPower)
ttfLong = crossover(ttf, 100)
ttfXLong = crossunder(ttf, -100)
//
// TII
//
majorLength = input(title="Major Length", type=input.integer, defval=60)
minorLength = input(title="Minor Length", type=input.integer, defval=30)
upperLevel = input(title="Upper Level", type=input.integer, defval=80)
lowerLevel = input(title="Lower Level", type=input.integer, defval=20)
sma = sma(src, majorLength)
positiveSum = 0.0
negativeSum = 0.0
for i = 0 to minorLength - 1 by 1
price = nz(src[i])
avg = nz(sma[i])
positiveSum := positiveSum + (price > avg ? price - avg : 0)
negativeSum := negativeSum + (price > avg ? 0 : avg - price)
negativeSum
tii = 100 * positiveSum / (positiveSum + negativeSum)
tiiLong = crossover(tii, 80)
tiiXLong = crossunder(tii,80)
//
// LOGIC
//
enterLong = (use == "TDI" and tdiLong) or (use == "TCF" and tcfLong) or (use == "TTF" and ttfLong) or (use == "TII" and tiiLong)
exitLong = (use == "TDI" and tdiXLong) or (use == "TCF" and tcfXLong) or (use == "TTF" and ttfXLong) or (use == "TII" and tiiXLong)
// Time range for Back Testing
btStartYear = input(title="Back Testing Start Year", type=input.integer, defval=2016)
btStartMonth = input(title="Back Testing Start Month", type=input.integer, defval=1)
btStartDay = input(title="Back Testing Start Day", type=input.integer, defval=1)
startTime = timestamp(btStartYear, btStartMonth, btStartDay, 0, 0)
btStopYear = input(title="Back Testing Stop Year", type=input.integer, defval=2028)
btStopMonth = input(title="Back Testing Stop Month", type=input.integer, defval=12)
btStopDay = input(title="Back Testing Stop Day", type=input.integer, defval=31)
stopTime = timestamp(btStopYear, btStopMonth, btStopDay, 0, 0)
window() => time >= startTime and time <= stopTime ? true : false
riskPerc = input(title="Max Position %", type=input.float, defval=20, step=0.5)
maxLossPerc = input(title="Max Loss Risk %", type=input.float, defval=5, step=0.25)
// Average True Range (ATR) measures market volatility.
// We use it for calculating position sizes.
atrLen = input(title="ATR Length", type=input.integer, defval=14)
stopOffset = input(title="Stop Offset", type=input.float, defval=1.5, step=0.25)
limitOffset = input(title="Limit Offset", type=input.float, defval=1.0, step=0.25)
atrValue = atr(atrLen)
// Calculate position size
maxPos = floor((strategy.equity * (riskPerc/100)) / src)
// The position sizing algorithm is based on two parts:
// a certain percentage of the strategy's equity and
// the ATR in currency value.
riskEquity = (riskPerc / 100) * strategy.equity
// Translate the ATR into the instrument's currency value.
atrCurrency = (atrValue * syminfo.pointvalue)
posSize0 = min(floor(riskEquity / atrCurrency), maxPos)
posSize = posSize0 < 1 ? 1 : posSize0
if (window())
strategy.entry("Long", long=true, qty=posSize0, when=enterLong)
strategy.close_all(when=exitLong)