Analyse mehrerer Symbole mit Python und MQL5 (Teil II): Hauptkomponentenanalyse zur Portfolio-Optimierung
307
0
Das Management des Gesamtrisikos, dem ein Portfolio ausgesetzt ist, ist eine ausreichend anspruchsvolle Aufgabe für alle Mitglieder unserer Handelsgemeinschaft. Wie kann man angesichts der großen Zahl von Anlagemöglichkeiten, die sich dem modernen Anleger bieten, in der heutigen Welt der ständig expandierenden Märkte eine umfassende Analyse durchführen und eine angemessene Vermögensaufteilung vornehmen? In unserer letzten Diskussion habe ich gezeigt, wie die Gesamtrendite des Portfolios mit SciPy maximiert werden kann. Heute werde ich mich darauf konzentrieren, wie Sie das Risiko/die Varianz eines Portfolios, das Sie möglicherweise haben, kontrollieren können. Es gibt viele mögliche Modelle, mit denen wir das Risiko unseres Portfolios kontrollieren können. Wir können ein beliebtes Werkzeug aus der Statistik, die Hauptkomponentenanalyse (PCA), verwenden, um die Gesamtvarianz unseres Portfolios effektiv zu verwalten.
Für Mitglieder unserer Community, die Expert Advisors verkaufen möchten, zeigt dieser Artikel, wie Sie eine nahtlose Erfahrung für Ihre Endnutzer schaffen können. Unsere Handelsanwendung ist flexibel und robust zugleich. Ich zeige Ihnen, wie Sie Handelsanwendungen erstellen können, die es Ihren Kunden ermöglichen, problemlos zwischen Handelsmodi mit hohem, mittlerem und niedrigem Risiko zu wechseln. Während der PCA-Algorithmus im Hintergrund die schwere Arbeit für Ihre Endnutzer übernimmt.
Überblick über die Methodik
In diesem Artikel werden wir ein Portfolio mit 10 Kryptowährungen verwalten. Kryptowährungen sind digitale Vermögenswerte, die auf einer speziellen Art von Netzwerk, dem sogenannten Blockchain-Netzwerk, existieren. Die Blockchain-Technologie ist ein Sicherheitsprotokoll, das es jedem Mitglied des Netzwerks nahezu unmöglich macht, betrügerische Transaktionen durchzuführen. Angesichts der Stärke des zugrundeliegenden Netzwerks war daher eine der ersten populären Anwendungen der Blockchain-Technologie die digitale Währung. Diese digitalen Vermögenswerte sind jedoch dafür bekannt, dass sie sehr volatil sind, und es kann für Anleger schwierig sein, ihr Risiko bei Investitionen in Krypto-Anlagen angemessen zu steuern. Glücklicherweise können wir statistische Methoden wie die PCA nutzen, um die Gesamtmenge der Varianz zu steuern, der wir bei Investitionen in Kryptowährungen ausgesetzt sein möchten.Die Hauptkomponentenanalyse ist ein Verfahren aus einem Zweig der multivariaten Statistik, der Faktorenanalyse. Die PCA findet in vielen Bereichen Anwendung, von der Bildanalyse bis zum maschinellen Lernen. In der Bildanalyse wird die PCA häufig für Aufgaben wie die Datenkomprimierung verwendet, während sie beim maschinellen Lernen meist zur Dimensionalitätsreduktion eingesetzt wird.
Bei der PCA geht es darum, für jede Spalte des Datensatzes einen Koeffizientenwert zu finden. Wenn jede Spalte mit ihrem Koeffizienten multipliziert wird, sollten die neuen Spalten, die wir erhalten, die Varianz des Datensatzes maximieren. Wenn wir diesen Vorgang erfolgreich abgeschlossen haben, haben wir die erste Hauptkomponente gefunden.
Die zweite Hauptkomponente ist orthogonal zur ersten, d. h. sie sind völlig unkorreliert, während gleichzeitig die Gesamtvarianz des Datensatzes maximiert wird. Dieses Muster setzt sich fort, bis wir genügend Komponenten erstellt haben, um die gesamte Varianz im ursprünglichen Datensatz zu berücksichtigen.
Ich werde Ihnen zeigen, wie jede einzelne Hauptkomponente diskreten Risikoniveaus entspricht, die wir als Einstellungen für unsere Handelsanwendungen verwenden können. So können Sie Ihre Risikoeinstellungen in wenigen Minuten intelligent verwalten.
Die ersten Schritte
Ich glaube, dass eine visuelle Demonstration des Algorithmus bei der Arbeit von großem Nutzen für Leser wäre, die zum ersten Mal mit dem Algorithmus in Berührung kommen. Ich nehme das Bild des MQL5-Logos in Abb. 1 und wandle es zunächst in Schwarz-Weiß um. Dieser Schwarz-Weiß-Filter erleichtert uns die Anwendung des PCA-Algorithmus und die visuelle Darstellung der Auswirkungen auf unsere Daten.
Abb. 1: Wir werden das obige MQL5-Logo verwenden, um die Funktionsweise des PCA-Algorithmus zu demonstrieren
Da wir nun ein Bild haben, mit dem wir arbeiten können, müssen wir unsere Python-Bibliotheken laden.
#Let's go import pandas as pd import numpy as np import MetaTrader5 as mt5 import seaborn as sns import matplotlib.pyplot as plt from sklearn.decomposition import PCA from skimage import io, color
Wir lesen das Bild ein und wandeln es in Schwarz-Weiß um.
# Load and preprocess the image
image = io.imread('mql5.png') # Replace with your image path
image_gray = image_gray = color.rgb2gray(image) # Convert to grayscale
Dann verkleinern wir das Bild auf 2 Dimensionen und wenden PCA auf 5 verschiedene Komponentenebenen an. Das Originalbild befindet sich ganz links in Abb. 2. Die erste Hauptkomponente maximiert die Varianz der Eingabedaten. Wie in dem Bild mit der Bezeichnung „1 Komponenten“ zu sehen ist, bleibt die allgemeine Struktur des Originalbildes einigermaßen erhalten. Obwohl der Text „MQL5“ in der Mitte des Bildes nicht mehr lesbar ist, kann man aus dem Bild schließen, dass es einen schwarzen Hintergrund mit einer weißen Struktur in der Mitte gibt.
Bei Verwendung von 5 Hauptkomponenten ist der Text im Bild lesbar. Allerdings gehen feine Details wie die hellgrauen, in den Hintergrund gestylten Symbole verloren und erfordern mehr Komponenten, um wiederhergestellt zu werden.
Diese Übung sollte Ihnen ein intuitives Verständnis dafür vermitteln, dass der PCA-Algorithmus versucht, kompakte und unkorrelierte Darstellungen der ursprünglichen Eingabedaten zu erstellen. Diese Aufgabe wird durch die Erstellung aufeinander folgender Linearkombinationen der Eingabedaten erfüllt, die die Varianz der Eingabedaten maximieren.
# Flatten the image
h, w = image_gray.shape
image_flattened = image_gray.reshape(h, w)
# Apply PCA with different numbers of components
n_components_list = [1,5,20,50,100] # Number of components to keep
fig, axes = plt.subplots(1, len(n_components_list) + 1, figsize=(20, 10))
axes[0].imshow(image_gray, cmap='gray')
axes[0].set_title("Original Image")
axes[0].axis('off')
for i, n_components in enumerate(n_components_list):
# Initialize PCA and transform the flattened image
pca = PCA(n_components=n_components)
pca.fit(image_flattened)
# Transform and inverse transform the image
transformed_image = pca.transform(image_flattened)
reconstructed_image = pca.inverse_transform(transformed_image).reshape(h, w)
# Plot the reconstructed image
axes[i + 1].imshow(reconstructed_image, cmap='gray')
axes[i + 1].set_title(f"{n_components} Components")
axes[i + 1].axis('off')
plt.tight_layout()
plt.show()
Abb. 2: Die ersten 2 Hauptkomponenten, die unser MQL5-Logo zusammenfassen
Abb. 3: Die letzten 3 Hauptkomponenten, die unser MQL5-Logo zusammenfassen
Anstelle eines Bildes sind wir eher an der Maximierung oder Minimierung der Varianz eines Portfolios interessiert. Wir können dies erreichen, indem wir unserem PCA-Algorithmus einen Datensatz übergeben, der die Renditen der einzelnen Vermögenswerte im Portfolio enthält.
Abruf unserer Marktdaten
Um loszulegen, müssen wir zunächst sicherstellen, dass unser MetaTrader 5-Terminal in Betrieb ist.
mt5.initialize()
Listen wir nun alle Vermögenswerte auf, die wir in unserem Portfolio halten werden.
#List of cryptocurrencies we wish to invest crypto = [ "BCHUSD", #BitcoinCash "EOSUSD", #EOS "BTCUSD", #Bitcoin "ETHUSD", #Etherum "ADAUSD", #Cardano "XRPUSD", #Ripple "UNIUSD", #Monero "DOGUSD", #Dogecoin "LTCUSD", #Litecoin "SOLUSD" #Solana ]
Wir möchten 6 Jahre tägliche Marktdaten abrufen.
fetch = 365 * 6
Unser Modell wird 30 Tage in die Zukunft prognostizieren.
look_ahead = 30 Erstellen wir den Datenrahmen, in dem unsere Kryptowährungserträge gespeichert werden.
data = pd.DataFrame(columns=crypto,index=range(fetch))
Wir holen uns Marktkurse für jedes der Symbole, die wir in unserer Liste haben.
for i in range(0,len(crypto)): data[crypto[i]] = pd.DataFrame(mt5.copy_rates_from_pos(crypto[i],mt5.TIMEFRAME_M1,0,fetch)).loc[:,"close"]
Schauen wir uns unsere Marktdaten an.
data
Abb. 4: Visualisierung einiger der von uns gesammelten Marktdaten, die 6 Jahre historischer Preise einer Sammlung von Kryptowährungen aufzeichnen
Explorative Datenanalyse
Der Handel mit Kryptowährungen kann eine Herausforderung sein, da die Wertpapiere sehr volatil sind. Abb. 5 veranschaulicht die Performance eines Korbs von 10 Kryptowährungen über einen Zeitraum von 6 Jahren, von 2018 bis 2024. Der Spread zwischen den Vermögenswerten entwickelt sich und ist für einen Menschen möglicherweise nicht intuitiv zu berechnen oder effektiv zu nutzen.
data_plotting = data.iloc[:,:]/data.iloc[0,:]
sns.lineplot(data_plotting)
Abb. 5: Die Performance von 10 verschiedenen Kryptowährungen, in die wir hätten investieren können
Das durch die einzelnen Kryptowährungen in unser Portfolio eingebrachte Risiko kann als rollierende Standardabweichung der Renditen der einzelnen Symbole dargestellt werden. Aus Abbildung 6 geht hervor, dass sich Perioden mit hoher Volatilität zu häufen scheinen. Einige Märkte weisen jedoch ein volatileres Verhalten auf als andere Märkte.
plt.plot(data_plotting.iloc[:,0].rolling(14).std()) plt.plot(data_plotting.iloc[:,1].rolling(14).std()) plt.plot(data_plotting.iloc[:,2].rolling(14).std()) plt.plot(data_plotting.iloc[:,3].rolling(14).std()) plt.plot(data_plotting.iloc[:,4].rolling(14).std()) plt.plot(data_plotting.iloc[:,5].rolling(14).std()) plt.plot(data_plotting.iloc[:,6].rolling(14).std()) plt.plot(data_plotting.iloc[:,7].rolling(14).std()) plt.plot(data_plotting.iloc[:,8].rolling(14).std()) plt.plot(data_plotting.iloc[:,9].rolling(14).std()) plt.legend(crypto) plt.title("The Risk Associated With Each of our Cryptocurrencies") plt.xlabel("Time") plt.ylabel("Standard Deviation")
Abb. 6: Die Standardabweichung der einzelnen Kryptowährungen in unserem Portfolio
Der PCA-Algorithmus hilft uns, die Gesamtvarianz des in Abbildung 6 dargestellten Portfolios zu minimieren oder zu maximieren. Der Versuch, manuell zu entscheiden, welche Vermögenswerte die Varianz unseres Portfolios bei 10 Vermögenswerten maximieren, könnte sich für einen Menschen als unmöglich erweisen, ohne Hilfe.Starke Korrelationen sind in gewisser Weise zu erwarten, wenn wir Vermögenswerte der gleichen Anlageklasse analysieren. Besonders interessant sind die Korrelationswerte zwischen dem:
- EOSUSD & XRPUSD
- DOGUSD & BCHUSD
#Correlation analysis
sns.heatmap(data.corr(),annot=True)
Abb. 7: Visualisierung der Korrelationsniveaus in unserem Portfolio von 10 Kryptowährungen
Berechnen wir die Veränderung des Preisniveaus über 2 Wochen.
#Calculate the change over 2 weeks data = data.diff(14).dropna().reset_index(drop=True)
Nun passen wir den Skalierer an.
scaler = RobustScaler() scaled_data = pd.DataFrame(scaler.fit_transform(data), columns=data.columns)
und nun das PCA-Objekt aus scikit learn auf unsere täglichen Marktrenditen.
pca = PCA() pca.fit(scaled_data)
Analysieren wir nun die erste Hauptkomponente. Das Vorzeichen des Koeffizienten gibt uns Aufschluss darüber, ob wir in jedem Markt Kauf- oder Verkaufs-Positionen einnehmen sollten. Positive Koeffizienten raten zu einer Kaufposition, negative Koeffizienten zu einer Verkaufsposition. Um die Varianz unseres Portfolios zu maximieren, schlägt der PCA-Algorithmus daher vor, in allen von uns ausgewählten Märkten zu verkaufen.
Für Händler, die Scalping-Strategien entwickeln wollen, ist diese erste Hauptkomponente der richtige Weg.
#High risk strategy pca.components_[0]
Darüber hinaus liefert uns jede Komponente auch optimale Kapitalallokationsverhältnisse, die die Varianz entsprechend maximieren oder minimieren. Um diese Informationen zu erhalten, müssen wir jedoch einige Transformationen auf die Komponente anwenden.
Die Komponente wird durch ihre L1-Norm geteilt. Die L1-Norm ist die Summe der absoluten Werte in der Komponente. Indem wir die einzelnen Hauptbelastungswerte durch ihre Gesamtsumme dividieren, erfahren wir die optimalen Anteile, die wir den einzelnen Vermögenswerten zuweisen sollten, um die Varianz unseres Portfolios zu maximieren.
Nachdem wir den Anteil jeder Kryptowährung an der Komponente berechnet haben, können wir die Asset Allocation Ratio mit der Anzahl der zu eröffnenden Positionen multiplizieren, um einen Näherungswert dafür zu erhalten, wie viele Positionen wir in jedem Markt eröffnen sollten. Wir haben die Summe berechnet, um zu beweisen, dass die Gesamtpositionen 100 ergeben, wenn wir die Asset Allocation Ratio mit 100 multiplizieren.
#High risk asset allocations can be estimated from the first principal component high_risk_asset_allocation = pca.components_[0] / np.linalg.norm(pca.components_[0],1) np.sum(high_risk_asset_allocation * 100)
Wenn wir beispielsweise 10 Positionen nach der Hochrisikostrategie eröffnen wollen, schlägt unsere primäre Komponente vor, dass wir 1 Position in BCHUSD (Bitcoin Cash) verkaufen. Der Dezimalteil des Koeffizienten kann als Position einer etwas kleineren Losgröße interpretiert werden. Es kann sich jedoch als sehr zeitaufwendig erweisen, dies in unserem Portfolio genau zu berücksichtigen. Es kann einfacher sein, sich auf den ganzzahligen Teil der Zuordnung zu verlassen.
high_risk_asset_allocation * 10 Kommen wir nun zu den Hauptkomponenten mit mittlerem Risiko.
#Mid risk strategy pca.components_[len(crypto)//2]
Und schließlich schlagen unsere risikoarmen Hauptkomponenten eine ganz andere Handelsstrategie vor.
#Low risk strategy pca.components_[len(crypto)-1]
Wir speichern diese Hauptkomponenten in einer Textdatei speichern, damit wir die Ergebnisse in unserer MetaTrader 5 Handelsanwendung verwenden können.
np.savetxt("LOW RISK COMPONENTS.txt",pca.components_[len(crypto)-1]) np.savetxt("MID RISK COMPONENTS.txt",pca.components_[len(crypto)//2]) np.savetxt("HIGH RISK COMPONENTS.txt",pca.components_[0])
Implementierung in MQL5
Wir sind nun bereit, mit der Implementierung unserer MetaTrader 5 Handelsanwendung zu beginnen.
Unsere Handelsanwendung wird versuchen, den Ergebnissen unserer optimalen Vermögensallokation zu folgen. Wir eröffnen nur 1 Handelsgeschäft in jedem Markt entsprechend der aktuellen Risikoeinstellung, die der Nutzer gewählt hat. Die Handelsanwendung nutzt den gleitenden Durchschnitt und den Stochastik-Oszillator, um die Einstiegszeit zu bestimmen.
Wenn die Hauptkomponente darauf hindeutet, dass wir eine Kaufpositionen auf dem Markt eingehen sollten, warten wir darauf, dass die Kurse über den gleitenden Durchschnitt auf diesem Markt steigen und der Stochastik-Oszillator über 50 liegt. Sobald beide Bedingungen erfüllt sind, gehen wir unsere Kaufpositionen ein und setzen entsprechend unsere Take-Profit und Stop-Loss unter Verwendung der ATR. Wenn wir unsere Markteintritte auf diese Weise timen, werden wir hoffentlich im Laufe der Zeit stabilere und konsistentere Einstiegssignale erhalten.
Zunächst definieren wir den nutzerdefinierten Enumerator, der dem Endnutzer die Kontrolle über die Risikoparameter unserer Handelsanwendung gibt.
//+------------------------------------------------------------------+ //| PCA For Portfolio Optimization.mq5 | //| Gamuchirai Zororo Ndawana | //| https://www.mql5.com/en/gamuchiraindawa | //+------------------------------------------------------------------+ #property copyright "Gamuchirai Zororo Ndawana" #property link "https://www.mql5.com/en/gamuchiraindawa" #property version "1.00" //+------------------------------------------------------------------+ //| Custom enumerations | //+------------------------------------------------------------------+ enum risk_level { High=0, Mid=1, Low=2 };
Laden Sie die benötigten Bibliotheken ein.
//+------------------------------------------------------------------+ //| Libraries | //+------------------------------------------------------------------+ #include <Trade\Trade.mqh> CTrade Trade;
Wir definieren konstante Werte, die sich zu keinem Zeitpunkt ändern werden.
//+------------------------------------------------------------------+ //| Constants values | //+------------------------------------------------------------------+ const double high_risk_components[] = {#include "HIGH RISK COMPONENTS.txt"}; const double mid_risk_components[] = {#include "MID RISK COMPONENTS.txt"}; const double low_risk_components[] = {#include "LOW RISK COMPONENTS.txt"}; const string crypto[] = {"BCHUSD","EOSUSD","BTCUSD","ETHUSD","ADAUSD","XRPUSD","UNIUSD","DOGUSD","LTCUSD","SOLUSD"};
Unsere globalen Variablen, die wir in unserem Programm verwenden werden.
//+------------------------------------------------------------------+ //| Global variables | //+------------------------------------------------------------------+ double current_risk_settings[]; double vol,bid,ask; int atr_handler; int stoch_handler; int ma_handler; double atr_reading[],ma_reading[],stoch_reading[];
Wir werden es dem Endnutzer ermöglichen, die Risikoeinstellungen des Handelskontos und die gewünschte Losgröße dynamisch zu steuern.
//+------------------------------------------------------------------+ //| Inputs | //+------------------------------------------------------------------+ input group "Risk Levels" input risk_level user_risk = High; //Which risk level should we use? input group "Money Management" input int lot_multiple = 1; //How big should out lot size be?
Wenn unsere Handelsanwendung geladen wird, laden wir zunächst unsere Hauptkomponenten entsprechend der vom Nutzer gewählten Risikoeinstellung. All dies wird von der „Setup“-Funktion für uns übernommen.
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Setup our market data setup(); //--- return(INIT_SUCCEEDED); }
Wenn wir den Expert Advisor nicht mehr verwenden, sollten wir die nicht mehr benötigten Ressourcen freigeben.
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- Release the indicators IndicatorRelease(atr_handler); IndicatorRelease(ma_handler); IndicatorRelease(stoch_handler); }
Schließlich, wenn wir aktualisierte Preise erhalten, lassen Sie uns ein Portfolio von 1 Position in jedem Kryptowährungsmarkt halten. Die Position, die wir einnehmen werden, hängt von den Risikoeinstellungen ab, die der Nutzer gewählt hat. Je nach Risikoeinstellung kann es erforderlich sein, eine Kauf- oder Verkaufsposition einzunehmen, um die Schwankungen im Portfolio zu kontrollieren.
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- Ensure we always have 10 positions if(PositionsTotal() < 10) { //--- Let's see which market we aren't in for(int i = 0; i < 10; i++) { //--- Check if we can now enter that market if(!PositionSelect(crypto[i])) { check_setup(i); } } } }
Die Einrichtungsfunktion ermittelt, welche Risikoeinstellung der Endnutzer gewählt hat, und lädt dann die entsprechende Hauptkomponente.
//+------------------------------------------------------------------+ //| Setup our market data | //+------------------------------------------------------------------+ void setup(void) { //--- First let us define the current risk settings switch(user_risk) { //--- The user selected high risk case 0: { ArrayCopy(current_risk_settings,high_risk_components,0,0,WHOLE_ARRAY); Comment("EA in high risk mode"); break; } //--- The user selected mid risk case 1: { ArrayCopy(current_risk_settings,mid_risk_components,0,0,WHOLE_ARRAY); Comment("EA in mid risk mode"); break; } //--- The user selected low risk //--- Low risk is also the default setting for safety! default: { ArrayCopy(current_risk_settings,low_risk_components,0,0,WHOLE_ARRAY); Comment("EA in low risk mode"); break; } } }
Da wir aktiv mit 10 verschiedenen Symbolen handeln, benötigen wir eine Funktion, die für das Abrufen von Marktdaten zu jedem Symbol verantwortlich ist. Die unten definierte Funktion „update“ wird diese Aufgabe für uns übernehmen. Jedes Mal, wenn die Funktion aufgerufen wird, lädt sie den aktuellen Geld- und Briefkurs zusammen mit anderen technischen Indikatorwerten, die aus dem angegebenen Markt berechnet werden, in den Speicher. Sobald wir die Daten verwendet und entschieden haben, welche Maßnahme zu ergreifen ist, lädt die Funktion die Marktdaten des nächsten Symbols in den Speicher.
//+------------------------------------------------------------------+ //| Update our system varaibles | //+------------------------------------------------------------------+ void update(string market) { //--- Get current prices bid = SymbolInfoDouble(market,SYMBOL_BID); ask = SymbolInfoDouble(market,SYMBOL_ASK); //--- Get current technical readings atr_handler = iATR(market,PERIOD_CURRENT,14); stoch_handler = iStochastic(market,PERIOD_CURRENT,5,3,3,MODE_EMA,STO_CLOSECLOSE); ma_handler = iMA(market,PERIOD_CURRENT,30,0,MODE_EMA,PRICE_CLOSE); //--- Copy buffer CopyBuffer(atr_handler,0,0,1,atr_reading); CopyBuffer(ma_handler,0,0,1,ma_reading); CopyBuffer(stoch_handler,0,0,1,stoch_reading); //--- }
Schließlich benötigen wir eine Funktion, die prüft, ob wir eine Position eröffnen können, die mit den aktuellen Risikoeinstellungen, die der Nutzer angegeben hat, übereinstimmt. Wenn dies nicht möglich ist, geben wir dem Endverbraucher eine aussagekräftige Erklärung, warum wir keine Position in diesem Markt eröffnen können.
//+------------------------------------------------------------------+ //| Open a position if we can | //+------------------------------------------------------------------+ void check_setup(int idx) { //--- The function takes the index of the symbol as its only parameter //--- It will look up the principal component loading of the symbol to determine whether it should buy or sell update(crypto[idx]); vol = lot_multiple * SymbolInfoDouble(crypto[idx],SYMBOL_VOLUME_MIN); if(current_risk_settings[idx] > 0) { if((iClose(crypto[idx],PERIOD_D1,0) > ma_reading[0]) && (stoch_reading[0] > 50)) { Comment("Analyzing: ",crypto[idx],"\nMA: ",ma_reading[0],"\nStoch: ",stoch_reading[0],"\nAction: Buy"); Trade.Buy(vol,crypto[idx],ask,(ask - (atr_reading[0] * 3)),(ask + (atr_reading[0] * 3)),"PCA Risk Optimization"); return; } else { Comment("Waiting for an oppurtunity to BUY: ",crypto[idx]); } } else if(current_risk_settings[idx] < 0) { if((iClose(crypto[idx],PERIOD_D1,0) < ma_reading[0]) && (stoch_reading[0] < 50)) { Comment("Analyzing: ",crypto[idx],"\nClose: ","\nMA: ",ma_reading[0],"\nStoch: ",stoch_reading[0],"\nAction: Sell"); Trade.Sell(vol,crypto[idx],bid,(bid + (atr_reading[0] * 3)),(bid - (atr_reading[0] * 3)),"PCA Risk Optimization"); return; } else { Comment("Waiting for an oppurtunity to SELL: ",crypto[idx]); return; } } Comment("Analyzing: ",crypto[idx],"\nMA: ",ma_reading[0],"\nStoch: ",stoch_reading[0],"\nAction: None"); return; }; //+------------------------------------------------------------------+
Abb. 8: Anzeige unseres Expertenberaters in MetaTrader 5
Abb. 9: Anpassen der Risikoparameter unserer Handelsanwendung
Abb. 10: Unsere Handelsanwendung wird in Echtzeit auf realen Marktdaten getestet
Schlussfolgerung
PCA wird normalerweise als ein etwas kompliziertes Thema angesehen, was auf die mathematische Notation zurückzuführen ist, die zum Erlernen des Konzepts erforderlich ist. Dieser Artikel hat Ihnen jedoch hoffentlich gezeigt, wie Sie PCA auf einfache Weise nutzen können, sodass Sie noch heute mit der Anwendung beginnen können, selbst wenn Sie sich zum ersten Mal mit dem Thema befassen.
Die Steuerung des Risikos in Ihrer Portfolioallokation ist keine einfache Aufgabe. Mathematische Instrumente und Modelle sind das beste Mittel, um das Risiko, dem Sie auf den Finanzmärkten ausgesetzt sind, zu messen und zu steuern. Vor allem, wenn die Zahl der Märkte, an denen Sie teilnehmen möchten, groß wird.
Ob wir nun 10 oder 100 Symbole haben, PCA wird uns immer zeigen, welche Kombinationen das Risiko im Portfolio maximieren und welche Kombinationen unser Portfoliorisiko minimieren werden.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/16273
Ökonometrische Instrumente zur Prognose der Volatilität: das GARCH-Modell
MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 45): Reinforcement Learning mit Monte-Carlo
Chaostheorie im Handel (Teil 1): Einführung, Anwendung auf den Finanzmärkten und Lyapunov-Exponent
Erforschung der Kryptographie in MQL5: Ein Schritt-für-Schritt-Ansatz
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.