Verschaffen Sie sich einen Vorteil auf jedem Markt (Teil II): Vorhersage technischer Indikatoren

Einführung

Anleger, die maschinelles Lernen in elektronischen Handelsumgebungen einsetzen wollen, stehen vor zahlreichen Herausforderungen, und die Realität ist, dass viele nicht die gewünschten Ergebnisse erzielen. In diesem Artikel sollen einige Gründe hervorgehoben werden, warum meiner Meinung nach ein aufstrebender algorithmischer Händler im Verhältnis zur Komplexität seiner Strategien keine zufriedenstellenden Erträge erzielen kann. Ich werde aufzeigen, warum die Vorhersage des Preises eines Finanztitels oft nicht über 50 % Richtigkeit hinauskommt und wie man stattdessen durch die Konzentration auf die Vorhersage von Werten technischer Indikatoren die Richtigkeit auf etwa 70 % verbessern kann. Dieser Leitfaden enthält schrittweise Anleitungen zu bewährten Verfahren für die Zeitreihenanalyse.

Am Ende dieses Artikels werden Sie ein solides Verständnis dafür haben, wie Sie mit Python und MQL5 die Richtigkeit Ihrer maschinellen Lernmodelle verbessern und führende Indikatoren für Marktveränderungen effektiver als andere Teilnehmer entdecken können.

Vorhersage von Indikatorwerten

Wir werden historische Daten von unserem MetaTrader 5-Terminal abrufen und sie mit Hilfe von Standard-Python-Bibliotheken analysieren. Diese Analyse wird zeigen, dass die Vorhersage von Veränderungen bei den Indikatorwerten effektiver ist als die Vorhersage von Wertpapierkursveränderungen. Dies ist richtig, weil wir die Faktoren, die den Preis eines Wertpapiers beeinflussen, nur teilweise beobachten können. In der Realität können wir nicht jede einzelne Variable modellieren, die den Preis eines Symbols beeinflusst, da sie sehr zahlreich und komplex ist. Wir können jedoch alle Faktoren, die den Wert eines technischen Indikators beeinflussen, vollständig beobachten.

Ich werde zunächst das Prinzip demonstrieren und dann am Ende unserer Diskussion erklären, warum dieser Ansatz besser funktioniert. Wenn man das Prinzip zuerst in der Praxis sieht, wird die theoretische Erklärung leichter zu verstehen sein. Wählen Sie zunächst das Symbol für die Symbolliste im Menü oberhalb des Charts.

Unsere Ziele sind hier auf das Abrufen von Daten ausgerichtet:

• Öffnen Sie Ihr MetaTrader 5-Terminal.
• Wählen Sie das Symbol für die Symbolliste im Menü oberhalb des Charts.
• Wählen Sie das gewünschte Symbol und den Zeitrahmen für Ihre Analyse.
• Exportieren Sie die historischen Daten in eine Datei mit kommagetrennten Werten (csv).

Abb. 1: Historische Daten abrufen.

Suchen Sie nach dem Symbol, das Sie modellieren möchten.

Abb. 2: Suche nach dem gewünschten Symbol.

Wählen Sie anschließend im Menü den Tabulator „Bars“ und fordern Sie so viele Daten wie möglich an.

Abb. 3: Abfrage historischer Daten.

Wählen Sie im unteren Menü die Option „Export Bars“, damit wir mit der Analyse unserer Daten in Python beginnen können.

,

Abb. 4: Exportieren unserer historischen Daten.

Wie üblich beginnen wir damit, die benötigten Bibliotheken zu importieren.

#Load libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Als Nächstes lesen wir unsere historischen Marktdaten ein. Beachten Sie, dass das MetaTrader 5-Terminal csv-Dateien exportiert, die durch Tabulatoren getrennt sind. Daher übergeben wir die Tabulator-Notation an den Separator-Parameter unseres Aufrufs an pandas, die csv-Datei zu lesen.

#Read the data
csv = pd.read_csv("/content/Volatility 75 Index_M1_20190101_20240131.csv",sep="\t")
csv

Nachdem wir unsere historischen Daten eingelesen haben, sieht es wie folgt aus. Wir müssen die Titel der Spalten ein wenig umformatieren und auch einen technischen Indikator hinzufügen.

Abb. 5: Unsere historischen Daten von unserem MetaTrader 5 Terminal.

Wir werden nun die Spalten umbenennen.

#Format the data
csv.rename(columns={"<DATE>":"date","<TIME>":"time","<TICKVOL>":"tickvol","<VOL>":"vol","<SPREAD>":"spread","<OPEN>":"open","<HIGH>":"high","<LOW>":"low","<CLOSE>":"close"},inplace=True)
csv.ta.sma(length= 60,append=True)
csv.dropna(inplace=True)
csv

Abb. 6: Formatieren unserer Daten.

Jetzt können wir unsere Eingaben definieren.

#Define the inputs
predictors = ["open","high","low","close","SMA_60"]

Als Nächstes werden wir unsere Daten so skalieren, dass unser Modell ausreichend trainieren kann.

#Scale the data
csv["open"] = csv["open"] /csv.loc[0,"open"]
csv["high"] = csv["high"] /csv.loc[0,"high"]
csv["low"] = csv["low"] /csv.loc[0,"low"]
csv["close"] = csv["close"] /csv.loc[0,"close"]
csv["SMA_60"] = csv["SMA_60"] /csv.loc[0,"SMA_60"]
    

Wir werden diese Aufgabe als ein Klassifizierungsproblem angehen. Unser Ziel wird kategorisch sein. Ein Zielwert (target value) von 1 bedeutet, dass der Kurs des Wertpapiers innerhalb von 60 Kerzen gestiegen ist, und ein Zielwert von 0 bedeutet, dass der Kurs im gleichen Zeitraum gefallen ist. Beachten Sie, dass wir zwei Ziele haben. Ein Ziel dient der Überwachung der Veränderung des Schlusskurses, das andere der Überwachung der Veränderung des gleitenden Durchschnitts.

Ein Zielwert von 1 bedeutet, dass der zukünftige Wert des gleitenden Durchschnitts in den nächsten 60 Kerzen größer sein wird, und umgekehrt bedeutet ein Zielwert von 0, dass der Wert des gleitenden Durchschnitts in den nächsten 60 Kerzen fallen wird.

#Define the close
csv["Target Close"] = 0
csv["Target MA"] = 0

Legen wir fest, wie weit wir in die Zukunft schauen möchten.

#Define the forecast horizon
look_ahead = 60

Codieren wir die Zielwerte.

#Set the targets
csv.loc[csv["close"] > csv["close"].shift(-look_ahead) ,"Target Close"] = 0
csv.loc[csv["close"] < csv["close"].shift(-look_ahead) ,"Target Close"] = 1
csv.loc[csv["SMA_60"] > csv["SMA_60"].shift(-look_ahead) ,"Target MA"] = 0
csv.loc[csv["SMA_60"] < csv["SMA_60"].shift(-look_ahead) ,"Target MA"] = 1
csv = csv[:-look_ahead]

Der einzige Unterschied besteht darin, dass unsere Modelle beim ersten Test versuchen, die Veränderung des Schlusskurses vorherzusagen, während sie beim zweiten Test stattdessen versuchen, die Veränderung eines technischen Indikators vorherzusagen, in unserem Beispiel den gleitenden Durchschnitt.

Nachdem wir unsere Ziele definiert haben, können wir nun die Modelle importieren, die wir für unsere Analyse benötigen.

#Get ready
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from xgboost import XGBClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
from sklearn.decomposition import PCA
from sklearn.model_selection import TimeSeriesSplit

Wir werden eine Aufteilung der Zeitreihen vorbereiten, um zu bewerten, wo unser Validierungsfehler geringer ist. Zusätzlich werden wir unsere Eingabedaten mit Hilfe der Hauptkomponentenanalyse (PCA) in sklearn transformieren. Dieser Schritt ist notwendig, weil unsere Eingabespalten korreliert sein können, was den Lernprozess unseres Modells behindern könnte. Durch die Durchführung der PCA transformieren wir unseren Datensatz in eine Form, die gewährleistet, dass keine Korrelation zwischen den Eingaben besteht, und verbessern so die Leistung unseres Modells.

#Time series split
splits = 10
gap = look_ahead
models_close = ["Logistic Regression","LDA","XGB","Nerual Net Simple","Nerual Net Large"]
models_ma = ["Logistic Regression","LDA","XGB","Nerual Net Simple","Nerual Net Large"]
#Prepare the data
pca = PCA()
csv_reduced = pd.DataFrame(pca.fit_transform(csv.loc[:,predictors]))

Betrachten wir nun unser Maß für die Richtigkeit, indem wir ein neuronales Netz verwenden, das versucht, Änderungen des Schlusskurses direkt vorherzusagen.

#Fit the neural network predicting close price
model_close = MLPClassifier(solver='lbfgs',alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)
model_close.fit(csv_reduced.loc[0:300000,:],csv.loc[0:300000,"Target Close"])
print("Close accuracy: ",accuracy_score(csv.loc[300070:,"Target Close"], model_close.predict(csv_reduced.loc[300070:,:])))

Richtigkeit der Schlusskurse:  0.4990962620254304

Unsere Richtigkeit bei der Vorhersage von Veränderungen des Schlusskurses lag bei 49,9 %. Das ist nicht beeindruckend, wenn man bedenkt, wie viel Komplexität wir in Kauf genommen haben. Wir hätten das gleiche Maß an Richtigkeit auch mit einem einfacheren Modell erreichen können, das leichter zu pflegen und zu verstehen ist, und wenn wir außerdem nur in 49 % der Fälle richtig liegen, dann bleiben wir in einer unrentablen Position. Vergleichen wir dies mit unserer Richtigkeit bei der Vorhersage von Veränderungen des gleitenden Durchschnittsindikators.

#Fit the model predicting the moving average
model_ma = MLPClassifier(solver='lbfgs',alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)
model_ma.fit(csv_reduced.loc[0:300000,:],csv.loc[0:300000,"Target MA"])
print("MA accuracy: ",accuracy_score(csv.loc[300070:,"Target MA"], model_ma.predict(csv_reduced.loc[300070:,:])))

MA Richtigkeit:  0.6879839284668174

Die Richtigkeit unseres Modells betrug 68,8 % bei der Vorhersage der Veränderungen des gleitenden Durchschnitts gegenüber 49,9 % bei der Vorhersage der Preisveränderungen. Dies ist eine akzeptable Richtigkeit im Verhältnis zu der Komplexität der von uns verwendeten Modellierungstechnik.

Wir werden nun eine Reihe von Modellen anwenden und sehen, welches Modell die Preisänderungen am besten vorhersagen kann und welches Modell die Änderungen des gleitenden Durchschnitts am besten vorhersagen kann.

#Error metrics
tscv = TimeSeriesSplit(n_splits=splits,gap=gap)
error_close_df = pd.DataFrame(index=np.arange(0,splits),columns=models_close)
error_ma_df = pd.DataFrame(index=np.arange(0,splits),columns=models_ma)

Wir werden zunächst die Richtigkeit jedes unserer ausgewählten Modelle bei der Vorhersage des Schlusskurses bewerten.

#Training each model to predict changes in the close price
for i,(train,test) in enumerate(tscv.split(csv)):
    model= MLPClassifier(solver='lbfgs',alpha=1e-5,hidden_layer_sizes=(20, 10), random_state=1)
    model.fit(csv_reduced.loc[train[0]:train[-1],:],csv.loc[train[0]:train[-1],"Target Close"])
    error_close_df.iloc[i,4] = accuracy_score(csv.loc[test[0]:test[-1],"Target Close"],model.predict(csv_reduced.loc[test[0]:test[-1],:]))

Abb. 7: Die Richtigkeit der verschiedenen Modelle zur Klassifizierung von Preisänderungen.

Abb. 8: Eine Visualisierung der Leistung jedes unserer Modelle.

Wir können die höchste Richtigkeit der einzelnen Modelle bei der Vorhersage des Schlusskurses bewerten.

for i in enumerate(np.arange(0,error_close_df.shape[1])):
  print(error_close_df.columns[i[0]]," ", error_close_df.iloc[:,i[0]].max())

Logistische Regression   0.5219959737302399
LDA   0.5192457894678943
XGB   0.5119523008041539
Neuronales Netz Einfach   0.5234700724948571
Neuronales Netz Groß   0.5186627504042771

Wie wir sehen, hat keines unserer Modelle besonders gut abgeschnitten. Sie lagen alle innerhalb einer Bandbreite um 50 %, wobei unser Modell der linearen Diskriminanzanalyse (LDA) die beste Leistung der Gruppe erzielte.

Andererseits haben wir jetzt festgestellt, dass unsere Modelle eine höhere Richtigkeit bei der Vorhersage von Veränderungen bestimmter technischer Indikatoren aufweisen. Wir wollen nun aus unserer Kandidatengruppe ermitteln, welches Modell bei der Vorhersage von Veränderungen des gleitenden Durchschnitts am besten abschneidet.

#Training each model to predict changes in a technical indicator (in this example simple moving average) instead of close price.
for i,(train,test) in enumerate(tscv.split(csv)):
    model= MLPClassifier(solver='lbfgs',alpha=1e-5,hidden_layer_sizes=(20, 10), random_state=1)
    model.fit(csv_reduced.loc[train[0]:train[-1],:],csv.loc[train[0]:train[-1],"Target MA"])
    error_ma_df.iloc[i,4] = accuracy_score(csv.loc[test[0]:test[-1],"Target MA"],model.predict(csv_reduced.loc[test[0]:test[-1],:]))

Abb. 9: Die Richtigkeit unserer Modelle bei der Vorhersage von Veränderungen des gleitenden Durchschnitts,

Abb. 10: Eine Darstellung der Richtigkeit unseres Modells bei der Vorhersage von Veränderungen des gleitenden Durchschnitts.

Wir bewerten die höchste Richtigkeit, die von jedem Modelltyp erreicht wird.

for i in enumerate(np.arrange(0,error_ma_df.shape[1])):
  print(error_ma_df.columns[i[0]]," ", error_ma_df.iloc[:,i[0]].max())

Logistische Regression   0.6927054112625546
LDA   0.696401658911147
XGB   0.6932664488520731
Neuronales Netz Einfach   0.6947955513019373
Neuronales Netz Groß   0.6965006655445914

Obwohl das große neuronale Netz die höchste Richtigkeit erreicht hat, würden wir es nicht in der Produktion einsetzen wollen, da seine Leistung instabil ist. Wir können dies an den 2 Punkten in der Grafik der Leistung des großen neuronalen Netzes erkennen, die weit unter seiner durchschnittlichen Leistung liegen. Aus den Ergebnissen geht hervor, dass das ideale Modell bei unserem aktuellen Datensatz komplexer als eine einfache logistische Regression und weniger kompliziert als ein großes neuronales Netz sein sollte.

Im Folgenden werden wir eine Handelsstrategie entwickeln, die zukünftige Bewegungen des gleitenden Durchschnittsindikators als Handelssignal vorhersagt. Unser Modell der Wahl wird das kleine neuronale Netz sein, weil es viel stabiler zu sein scheint.

Zunächst importieren wir die benötigten Bibliotheken.

#Import the libraries we need
import MetaTrader5 as mt5
import pandas_ta as ta
import pandas as pd

Als Nächstes richten wir unsere Handelsumgebung ein.

#Trading global variables
MARKET_SYMBOL = 'Volatility 75 Index'

#This data frame will store the most recent price update
last_close = pd.DataFrame()

#We may not always enter at the price we want, how much deviation can we tolerate?
DEVIATION = 10000

#We will always enter at the minimum volume
VOLUME = 0
#How many times the minimum volume should our positions be
LOT_MUTLIPLE = 1

#What timeframe are we working on?
TIMEFRAME = mt5.TIMEFRAME_M1

#Which model have we decided to work with?
neural_network_model= MLPClassifier(solver='lbfgs',alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)

Bestimmen wir das Mindestvolumen für das Symbol, das wir handeln möchten.

#Determine the minimum volume
for index,symbol in enumerate(symbols):
    if symbol.name == MARKET_SYMBOL:
        print(f"{symbol.name} has minimum volume: {symbol.volume_min}")
        VOLUME = symbol.volume_min * LOT_MULTIPLE

Wir können nun eine Funktion erstellen, die unsere Marktaufträge für uns ausführt.

# function to send a market order
def market_order(symbol, volume, order_type, **kwargs):
    #Fetching the current bid and ask prices
    tick = mt5.symbol_info_tick(symbol)
    
    #Creating a dictionary to keep track of order direction
    order_dict = {'buy': 0, 'sell': 1}
    price_dict = {'buy': tick.ask, 'sell': tick.bid}

    request = {
        "action": mt5.TRADE_ACTION_DEAL,
        "symbol": symbol,
        "volume": volume,
        "type": order_dict[order_type],
        "price": price_dict[order_type],
        "deviation": DEVIATION,
        "magic": 100,
        "comment": "Indicator Forecast Market Order",
        "type_time": mt5.ORDER_TIME_GTC,
        "type_filling": mt5.ORDER_FILLING_FOK,
    }

    order_result = mt5.order_send(request)
    print(order_result)
    return order_result

Außerdem benötigen wir eine weitere Funktion, die uns hilft, unsere Marktaufträge zu schließen.

# Closing our order based on ticket id
def close_order(ticket):
    positions = mt5.positions_get()

    for pos in positions:
        tick = mt5.symbol_info_tick(pos.symbol) #validating that the order is for this symbol
        type_dict = {0: 1, 1: 0}  # 0 represents buy, 1 represents sell - inverting order_type to close the position
        price_dict = {0: tick.ask, 1: tick.bid} #bid ask prices

        if pos.ticket == ticket:
            request = {
                "action": mt5.TRADE_ACTION_DEAL,
                "position": pos.ticket,
                "symbol": pos.symbol,
                "volume": pos.volume,
                "type": type_dict[pos.type],
                "price": price_dict[pos.type],
                "deviation": DEVIATION,
                "magic": 10000,
                "comment": "Indicator Forecast Market Order",
                "type_time": mt5.ORDER_TIME_GTC,
                "type_filling": mt5.ORDER_FILLING_FOK,
            }

            order_result = mt5.order_send(request)
            print(order_result)
            return order_result

    return 'Ticket does not exist'

Außerdem müssen wir den Datumsbereich festlegen, für den wir Daten abfragen wollen.

#Update our date from and date to
date_from = datetime(2024,1,1)
date_to = datetime.now()

Bevor wir die vom Makler angeforderten Daten weitergeben können, müssen wir sie zunächst in das gleiche Format vorverarbeiten, das unser Modell beim Training beobachtet hat.

#Let's create a function to preprocess our data
def preprocess(df):
    #Calculating 60 period Simple Moving Average
    df.ta.sma(length=60,append=True)
    #Drop any rows that have missing values
    df.dropna(axis=0,inplace=True)

Nun müssen wir in der Lage sein, eine Prognose von unserem neuronalen Netzwerk zu erhalten und diese Prognose als Handelssignal zu interpretieren, um zu kaufen oder zu verkaufen.

#Get signals from our model
def ai_signal():
    #Fetch OHLC data
    df = pd.DataFrame(mt5.copy_rates_range(market_symbol,TIMEFRAME,date_from,date_to))
    #Process the data
    df['time'] = pd.to_datetime(df['time'],unit='s')
    df['target'] = (df['close'].shift(-1) > df['close']).astype(int)
    preprocess(df)
    #Select the last row
    last_close = df.iloc[-1:,1:]
    #Remove the target column
    last_close.pop('target')
    #Use the last row to generate a forecast from our moving average forecast model
    #Remember 1 means buy and 0 means sell
    forecast = neural_network_model.predict(last_close)
    return forecast[0]

Schließlich fügen wir all dies zusammen, um unsere Handelsstrategie zu entwickeln.

#Now we define the main body of our trading algorithm
if __name__ == '__main__':
    #We'll use an infinite loop to keep the program running
    while True:
        #Fetching model prediction
        signal = ai_signal()
        
        #Decoding model prediction into an action
        if signal == 1:
            direction = 'buy'
        elif signal == 0:
            direction = 'sell'
        
        print(f'AI Forecast: {direction}')
        
        #Opening A Buy Trade
        #But first we need to ensure there are no opposite trades open on the same symbol
        if direction == 'buy':
            #Close any sell positions
            for pos in mt5.positions_get():
                if pos.type == 1:
                    #This is an open sell order, and we need to close it
                    close_order(pos.ticket)
            
            if not mt5.positions_totoal():
                #We have no open positions
                market_order(MARKET_SYMBOL,VOLUME,direction)
        
        #Opening A Sell Trade
        elif direction == 'sell':
            #Close any buy positions
            for pos in mt5.positions_get():
                if pos.type == 0:
                    #This is an open buy order, and we need to close it
                    close_order(pos.ticket)
            
            if not mt5.positions_get():
                #We have no open positions
                market_order(MARKET_SYMBOL,VOLUME,direction)
        
        print('time: ', datetime.now())
        print('-------\n')
        time.sleep(60)

Abb. 11: Unser Modell in Aktion.

Theoretische Erläuterung

Nach Ansicht des Verfassers ist einer der Gründe, warum wir bei der Vorhersage von Veränderungen der technischen Indikatoren eine höhere Richtigkeit beobachten können, die Tatsache, dass wir nie alle Variablen beobachten können, die den Preis eines Wertpapiers beeinflussen. Im besten Fall können wir sie nur teilweise beobachten, während wir bei der Vorhersage der Veränderungen eines technischen Indikators alle Inputs, die den technischen Indikator beeinflusst haben, vollständig kennen. Erinnern wir uns daran, dass wir sogar die genaue Formel eines jeden technischen Indikators kennen.

Abb. 12: Wir kennen die mathematische Beschreibung aller technischen Indikatoren, aber es gibt keine mathematische Formel für den Schlusskurs.

Der technische Indikator Money Flow Multiplier (MFM) wird beispielsweise mit der oben genannten Formel berechnet. Wenn wir also Veränderungen im MFM vorhersagen wollen, benötigen wir nur die Komponenten seiner Formel: den Schluss-, den Tief- und den Höchstkurs.

Im Gegensatz dazu gibt es für die Prognose des Schlusskurses keine spezifische Formel, die uns sagt, welche Inputs ihn beeinflussen. Dies führt oft zu einer geringeren Richtigkeit, was darauf hindeutet, dass unsere aktuellen Eingaben möglicherweise nicht informativ sind oder dass wir durch die Auswahl schlechter Eingaben zu viel Rauschen hinzugefügt haben.

Grundsätzlich besteht das Ziel des maschinellen Lernens darin, ein durch eine Reihe von Eingaben bestimmtes Ziel zu finden. Wenn wir einen technischen Indikator als Ziel verwenden, sagen wir damit im Wesentlichen aus, dass der technische Indikator von den Eröffnungs-, Schluss-, Tief- und Höchstkursen beeinflusst wird, was auch stimmt. Als Entwickler von Algorithmen verwenden wir unsere Tools jedoch oft umgekehrt. Wir verwenden eine Sammlung von Kursdaten und technischen Indikatoren, um den Kurs zu prognostizieren, was impliziert, dass technische Indikatoren den Kurs beeinflussen, was nicht der Fall ist und niemals der Fall sein wird.

Wenn wir versuchen, ein Ziel zu lernen, dessen zugrundeliegende Funktion nicht bekannt ist, fallen wir möglicherweise einer so genannten unechten Regression zum Opfer, die wir in unserer vorherigen Diskussion ausführlich erörtert haben. Einfach ausgedrückt: Ihr Modell kann eine Beziehung lernen, die es im wirklichen Leben nicht gibt. Darüber hinaus kann dieser Fehler durch täuschend niedrige Fehlerquoten bei der Validierung kaschiert werden, sodass es so aussieht, als ob das Modell ausreichend gelernt hätte, obwohl es in Wahrheit nichts über die reale Welt gelernt hat.

Um zu veranschaulichen, was eine unechte Regression ist, stellen wir uns vor, wir gehen einen Hügel hinunter und sehen kurz hinter dem Horizont eine vage Form. Wir sind zu weit weg, um zu erkennen, was es ist, aber nach dem, was ich gesehen habe, rufe ich „Da unten ist ein Hund“. Als wir ankommen, finden wir einen Busch, aber hinter dem Busch ist ein Hund.

Abb. 13: Könnte ich den Hund gesehen haben?

Können Sie das Problem schon erkennen? Ich würde den Sieg natürlich gerne als Beweis für meine perfekte Sehkraft von 20/20 beanspruchen, aber Sie wissen, dass es im Grunde genommen keine Möglichkeit gab, dass ich den Hund von dort aus, wo wir standen, als ich die Aussage machte, hätte sehen können, wir waren einfach zu weit weg und die Figur war von dort aus zu vage.

Es gab einfach keinen Zusammenhang zwischen den Eingaben, die ich auf dem Gipfel des Berges sah, und der Schlussfolgerung, zu der ich kam. Das heißt, die Eingabe- und Ausgabedaten waren unabhängig voneinander. Wenn ein Modell Eingabedaten betrachtet, die in keiner Beziehung zu den Ausgabedaten stehen, aber dennoch die richtige Antwort liefert, spricht man von einer unechten Regression. Irrtümliche Regressionen kommen immer wieder vor!

Da wir keine technischen Formeln haben, die beschreiben, was den Preis eines Wertpapiers beeinflusst, neigen wir dazu, falsche Regressionen durchzuführen, indem wir Inputs verwenden, die keinen Einfluss auf unser Ziel, den Schlusskurs, haben. Der Nachweis, dass eine Regression nicht falsch ist, kann schwierig sein. Es ist einfacher, ein Ziel zu verwenden, das eine bekannte Beziehung zu den Eingaben hat.

Schlussfolgerung

In diesem Artikel wurde aufgezeigt, warum die Praxis der direkten Vorhersage von Schlusskursen möglicherweise zugunsten der Vorhersage von Veränderungen bei technischen Indikatoren vernachlässigt werden sollte. Weitere Untersuchungen sind notwendig, um herauszufinden, ob es andere technische Indikatoren gibt, die eine genauere Vorhersage ermöglichen als der gleitende Durchschnitt. Allerdings sollten die Leser auch darauf hingewiesen werden, dass die Richtigkeit der Prognose des gleitenden Durchschnitts zwar relativ hoch ist, aber dennoch eine Verzögerung zwischen den Veränderungen des gleitenden Durchschnitts und den Preisveränderungen besteht.

Mit anderen Worten: Es ist möglich, dass der gleitende Durchschnitt fällt, während der Preis steigt. Wenn wir als MQL5-Gemeinschaft jedoch gemeinsam an der Verbesserung dieses Algorithmus arbeiten, bin ich zuversichtlich, dass wir schließlich ein neues Maß für die Richtigkeit erreichen können.