Neurostrukturelle Trading-Engine – NSTE (Teil I): Aufbau eines prop-firm-tauglichen Multi-Account-Systems
20
0
Einführung
Wenn Sie mit Kryptowährungs-CFDs auf Konten von Prop-Firmen handeln, kennen Sie die drei Arten, wie der Markt Ihnen den Tag verderben kann, noch bevor er richtig begonnen hat: Eine einzige volatile Kerze durchbricht Ihren ATR-basierten Stop und reißt Ihr tägliches Verlustlimit in einem Zug, Ihr Skript wechselt zwischen den Konten hin und her und schließt stillschweigend offene Positionen, oder ein unruhiger Seitwärtsmarkt zermürbt Ihren statistischen Vorteil mit Dutzenden kleiner Verluste bis auf null. Dieser Artikel löst alle drei Probleme.
Dies ist der erste Artikel einer 19-teiligen Serie über die Neuro-Structural Trading Engine, ein algorithmisches Handelssystem mit mehreren Konten, das für den gleichzeitigen Handel mit Kryptowährungs-CFDs (BTCUSD, ETHUSD) über mehrere Konten von Prop-Firmen hinweg entwickelt wurde. Das System vereint LSTM-Netze, eine auf Kompression basierende Regimeerkennung und von der Biologie inspirierte adaptive Algorithmen in einem einheitlichen Trading-Framework.
Dieser Artikel richtet sich an algorithmische Trader, die eine zuverlässige Grundlage benötigen, um automatisierte Strategien über mehrere Konten von Prop-Firmen hinweg auszuführen, ohne dabei die Drawdown-Regeln zu verletzen. Am Ende verfügen Sie über eine funktionierende Prozessarchitektur, eine auf festen Dollarbeträgen basierende Risikoberechnungsformel, einen Rauschfilter, der Sie vor ungünstigen Marktphasen schützt, sowie ein vollständiges Expert-Advisor-Grundgerüst, das Sie noch heute im Strategietester kompilieren und testen können.
Das System wurde auf der Grundlage von drei unverzichtbaren Grundsätzen entwickelt:
Grundsatz 1: Stop-Loss ist heilig
Bei jedem Handel wird ein fester Dollarbetrag (1,00 $) riskiert. Kein Prozentsatz des Preises. Kein ATR-Multiplikator. Ein strikt fixer Dollarbetrag. Die Lotgröße wird so angepasst, dass die SL-Distanz genau einem Risiko von 1,00 $ entspricht.
Formel:
lot = MAX_LOSS_DOLLARS / (sl_distance_points * tick_value)
Dadurch werden die katastrophalen Verluste von über 500 Dollar verhindert, die ATR-basierte Stopps in volatilen Kryptomärkten verursachen können. Wenn der Bitcoin-Kurs innerhalb weniger Minuten um 2.000 Dollar schwankt, kann ein auf der ATR basierender Stop Ihr gesamtes Tagesverlustlimit in einem einzigen Trade sprengen. Ein fester Dollar-Stop sorgt dafür, dass Sie – unabhängig davon, wie volatil der Markt auch wird – niemals mehr als den von Ihnen festgelegten Betrag verlieren.
Grundsatz 2: Ein Skript pro Konto
Die MetaTrader 5 Python-API (MetaTrader 5-Paket) ist ein Singleton. Der Aufruf von mt5.login() zum Wechseln des Kontos beendet alle offenen Trades auf dem aktuellen Terminal. Jedes Konto einer Prop-Firma führt einen eigenen, dedizierten Python-Prozess aus, der eine Verbindung zu seiner eigenen MetaTrader-5-Terminal-Instanz herstellt. Diese Architekturentscheidung war das Resultat einer schmerzhaften Lektion: Der Versuch, mehrere Konten von Prop-Firmen über ein einziges Skript zu verwalten, führte dazu, dass Trades unbemerkt geschlossen wurden, wenn das Skript zwischen den Konten wechselte.
Grundsatz 3: Zentrale Konfiguration, dezentrale Ausführung
Alle Handelsparameter sind in der Datei MASTER_CONFIG.json hinterlegt. Jedes Skript importiert Werte über config_loader.py. In keinem Ausführungsskript sind hartkodierte Handelsparameter enthalten. Dadurch werden versehentliche Änderungen an den Risikoparametern verhindert. Wenn man mit echtem Geld auf sechs verschiedenen Konten von Prop-Firmen handelt, ist das Letzte, was man will, dass eine versehentliche Änderung das Risiko von 1,00 $ auf 10,00 $ pro Trade erhöht.
Die Architektur „Ein-Skript-pro-Konto“
Jedes BRAIN-Skript führt einen eigenständigen Prozess aus, der mit einem eigenen MetaTrader 5-Terminal verbunden ist:
// --- Architecture Diagram: One-Script-Per-Account ---
+-------------------+ +-------------------+ +-------------------+
| BRAIN_Account_A | | BRAIN_Account_B | | BRAIN_Account_C |
| Process 1 | | Process 2 | | Process 3 |
+--------+----------+ +--------+----------+ +--------+----------+
| | |
v v v
+-------------------+ +-------------------+ +-------------------+
| MT5 Terminal 1 | | MT5 Terminal 2 | | MT5 Terminal 3 |
+-------------------+ +-------------------+ +-------------------+
Jedes BRAIN-Skript läuft in einer 60-Sekunden-Schleife:
- 100 1-Minuten-Datenbars aus dem MetaTrader 5-Terminal abrufen
- Berechnung von acht technischen Indikatoren (RSI, MACD, Bollinger-Bänder usw.)
- Überprüfung des Marktregimes mittels Kompressionsverhältnisanalyse
- LSTM-Prognose (BUY / SELL / HOLD) mit Konfidenzwert abrufen
- Den Handel ausführen, wenn das Signal alle Filter und den Konfidenzschwellenwert erfüllt
- Offene Positionen verwalten (Teilschließung bei 50 % TP, rollierender Stop-Loss)
- 60 Sekunden Pause, den gesamten Zyklus wiederholen
Das folgende Diagramm veranschaulicht die gesamte Architektur:
Abbildung 1. Drei unabhängige BRAIN-Prozesse sind jeweils mit einer eigenen MetaTrader 5-Terminalinstanz verbunden, für eine vollständige Isolation der Prozesse.
Diese Architektur lässt sich horizontal skalieren. Das Hinzufügen eines neuen Prop-Firm-Kontos bedeutet, dass ein neues BRAIN-Skript und eine neue MetaTrader-5-Terminal-Instanz hinzugefügt werden. Bestehende Prozesse sind davon nicht betroffen.
LSTM-Netzwerk
Das zentrale Vorhersagemodul nutzt eine gestapelte LSTM-Architektur (Long Short-Term Memory). LSTMs sind eine Art rekurrenter neuronaler Netze, die speziell dafür entwickelt wurden, langfristige Abhängigkeiten in sequenziellen Daten zu erlernen, wodurch sie sich gut für die Zeitreihenprognose auf den Finanzmärkten eignen.
Architektur-Spezifikationen:
- Eingabe: 8 Merkmale × 30 Zeitschritte = 240 Eingaben pro Vorhersage
- LSTM-Schicht 1: 128 versteckte Einheiten mit tanh-Aktivierung
- LSTM-Schicht 2: 128 versteckte Einheiten mit tanh-Aktivierung
- Dropout: 40 % zwischen den Schichten, um Überanpassung zu vermeiden
- Ausgabe: 3 Klassen (BUY, SELL, HOLD) mittels Softmax-Wahrscheinlichkeitsverteilung
Das Modell wird offline mithilfe der Walk-Forward-Methode trainiert und als .pth-Datei (PyTorch) exportiert. Im Live-Handel wird die Inferenz auf der CPU ausgeführt, da DirectML (AMD-GPU) den LSTM-Backward-Pass auf Kernel-Ebene nicht unterstützt. Die Forward-Pass-Inferenz auf der CPU dauert weniger als 10 ms pro Vorhersage, was für unseren 60-Sekunden-Handelszyklus mehr als ausreichend ist.
Das Training basiert auf einer 6-Komponenten-Fitnessfunktion, die mehrere Ziele miteinander in Einklang bringt:
- Gewinnquote (Bayessche A-posteriori-Verteilung mit einer Beta(10,10)-A-priori-Verteilung zur Berücksichtigung kleiner Stichproben)
- Profitfaktor (durchschnittlicher Gewinn / durchschnittlicher Verlust, muss über 1,5 liegen)
- Sharpe-Ratio (risikobereinigte Rendite, annualisiert)
- Maximale Drawdown-Strafe (exponentielle Strafe, wenn sich der Drawdown den Grenzwerten nähert)
- Handelsanzahl (für statistische Signifikanz sind mindestens 30 Beobachtungen erforderlich)
- Konsistenzwert über alle Walk-Forward-Fenster hinweg (bestraft das Überanpassen an einen einzelnen Zeitraum)
Die bayessche A-priori-Verteilung Beta(10,10) ist von entscheidender Bedeutung. Ohne diese Komponente würde ein Modell, das zwei Trades durchführt und beide gewinnt, eine Gewinnquote von 100 % aufweisen. Der Beta-Prior drängt den Posterior in Richtung 50 %, sodass erhebliche Belege erforderlich sind, bevor sich die Schätzung der Gewinnquote deutlich von der Basislinie entfernt.
Kompressionsbasierte Regimeerkennung
Die zentrale Erkenntnis hinter dem Regimenerkennungssystem besticht durch ihre Einfachheit:
Strukturierte Daten lassen sich gut komprimieren. Zufallsdaten lassen sich nur schlecht komprimieren.
Wenn die Kursentwicklung ein erkennbares Muster aufweist (Trend, Rückkehr zum Mittelwert oder eine andere Struktur), lassen sich die Daten auf eine geringere Größe komprimieren, da der Komprimierungsalgorithmus sich wiederholende Muster erkennen kann. Wenn die Kursentwicklung zufälliges Rauschen ist (unruhiger, richtungsloser Markt), ist der Kompressionseffekt minimal, da es keine Muster gibt, die man ausnutzen könnte.
Die Implementierung des Algorithmus ist unkompliziert:
- Nimm die letzten 100 Schlusskurse aus dem 1-Minuten-Chart.
- Wandle mit Pythons struct.pack in Bytes um.
- Komprimiere mit zlib auf der höchsten Komprimierungsstufe 9.
- Berechne: ratio = len(original_bytes) / len(compressed_bytes).
Das Kompressionsverhältnis gibt Aufschluss darüber, wie stark die aktuelle Kursentwicklung strukturiert ist:
// --- Regime Classification Thresholds --- ratio >= 3.5 -> CLEAN regime -> Market is structured, TRADE ratio >= 2.5 -> VOLATILE regime -> Moderate structure, HOLD ratio < 2.5 -> CHOPPY regime -> Random noise, HOLD
Die drei Regimezonen und ihre Auswirkungen auf den Handel:
Abbildung 2. Kompressionsbasierte Regimeerkennung. Die drei Marktregime (CLEAN, VOLATILE, CHOPPY), die anhand von Schwellenwerten für das Kompressionsverhältnis bestimmt werden. Nur im CLEAN-Regime wird gehandelt.
Handel ausschließlich im CLEAN-Marktregime. Dieser einzelne Filter eliminiert einen Großteil der Verlusttrades, die unter unruhigen Marktbedingungen auftreten. Im Backtesting verbesserte der Kompressionsfilter allein die Gewinnquote des Systems um etwa 12 Prozentpunkte im Vergleich zum Handel in allen Marktphasen.
Das Schöne an diesem Ansatz ist, dass er völlig modellunabhängig ist. Der Ansatz ist völlig modellagnostisch. Er hängt weder von Indikatoren noch von Mustern oder einer bestimmten Markttheorie ab. Er misst lediglich, ob die aktuellen Kursdaten eine verwertbare Struktur aufweisen, unabhängig davon, welche Form diese Struktur annimmt.
Risikomanagement mit festem Dollar-Risiko
Das Risikomanagementsystem basiert auf einer einzigen unveränderlichen Regel: Kein Trade darf mehr als 1,00 $ Verlust verursachen. Alles andere ergibt sich aus dieser Vorgabe.
Risikoparameter pro Handel:
- Maximaler Verlust: 1,00 $ pro Handel (absolute Obergrenze)
- Anfänglicher SL: 0,60 $ (anfänglicher Stop-Loss-Abstand in Dollar)
- Rolling SL: Teilt den Stopp-Abstand durch 1,5, wenn sich der Kurs positiv entwickelt
- Finaler SL: 1,00 $ (maximale Stop-Distanz nach allen rollierenden Anpassungen)
- TP = dreifache SL-Distanz (Risiko-Ertrags-Verhältnis von 1:3)
Der Mechanismus zur zweistufigen Gewinnmitnahme in der Praxis:
Abbildung 3. Zweistufige Gewinnentnahme. Bei Erreichen von 50 % der TP-Distanz wird die Hälfte der Position geschlossen und der Stop-Loss auf den Breakeven-Punkt verschoben. Die verbleibende Hälfte läuft bis zum vollständigen TP ohne jegliches Risiko
Dynamisches Take-Profit-System: Bei Erreichen von 50 % der TP-Distanz schließt das System die Hälfte der Position. Nach diesem Teilausstieg wird der Stop-Loss auf den Breakeven-Punkt (Einstiegskurs) verschoben. Das Ergebnis ist ein garantierter Gewinn aus der geschlossenen Hälfte sowie ein Free Runner, der weiterhin Gewinne erzielen kann, ohne dass dabei ein Verlustrisiko besteht. Dieser Mechanismus verwandelt jeden gewinnbringenden Trade in einen zweistufigen Gewinnrealisierungsprozess.
Sicherheitsgrenzen für Prop-Firmen:
- Tägliches Verlustlimit: 5 % des Kontostands
- Maximaler Drawdown 10 % des Kontostands, bezogen auf das maximale Equity
- Gewinnziel: 10 % des Kontostands
Sobald eine Grenze innerhalb einer Sicherheitsmarge erreicht wird, stellt BRAIN den Handel für dieses Konto vollständig ein. Dadurch stellen wir sicher, dass wir niemals gegen eine Regel der Prop-Firma verstoßen, was zur Kontoschließung und zum Verlust des bereitgestellten Kapitals führen würde.
Feature-Engineering-Pipeline
Das LSTM erhält 8 Merkmale, die aus den rohen 1-Minuten-OHLCV-Daten berechnet wurden. Jedes Merkmal wurde ausgewählt, um einen anderen Aspekt der Marktmikrostruktur zu erfassen:
| Merkmal | Berechnung | Zweck |
|---|---|---|
| RSI(14) | Relative-Stärke-Index, 14 Perioden | Erkennung von Überkauft- und Überverkauft-Situationen |
| MACD | EMA(12) – EMA(26) | Trendrichtung und Dynamik |
| MACD-Signal | EMA(9) der MACD-Linie | Bestätigung einer Trendwende |
| BB oberes Band | SMA(20) + 2*Standardabweichung | Obere Volatilitätsgrenze |
| BB unteres Band | SMA(20) – 2*Standardabweichung | Untere Volatilitätsgrenze |
| Momentum(10) | Close - Close[10] | Rohes Kursmomentum |
| ROC(10) | (Close-Close[10])/Close[10] | Prozentuale Veränderungsrate |
| ATR(14) | Average True Range, 14 Perioden | Messung der aktuellen Volatilität |
Bei der Normalisierung wird der globale Z-Score verwendet: Der Mittelwert des Datensatzes wird abgezogen und das Ergebnis durch die Standardabweichung geteilt. Dadurch wird sichergestellt, dass alle Merkmale über alle Instrumente hinweg skaleninvariant sind. Ohne Normalisierung würden die ATR-Werte für BTCUSD (die bei Hunderten Dollar liegen können) Kennzahlen wie den RSI (der zwischen 0 und 100 schwankt) dominieren.
MQL5-Implementierung
Die MQL5-Seite übernimmt die Handelsausführung. Die Python-Seite übernimmt die intelligenten Funktionen (LSTM-Inferenz, Regimeerkennung, Signalerzeugung). Die Kommunikation zwischen den beiden erfolgt über JSON-Signaldateien, die mit Python erstellt und vom MQL5-Expert-Advisor gelesen werden, der auf dem Chart läuft.
Im Folgenden sind die wichtigsten Details zur Implementierung des Expert Advisors aufgeführt. Der vollständige Quellcode steht als Anhang zu diesem Artikel zum Download bereit.
Eingabeparameter und Risikoeinstellungen
Der EA definiert zunächst Eingabeparameter, die die Einstellungen in der Datei MASTER_CONFIG.json widerspiegeln. Diese ermöglichen es dem Trader, die Risikoparameter direkt über die MetaTrader 5-Benutzeroberfläche anzupassen:
input group "=== Core Risk Settings ===" input double InpMaxLossDollars = 1.00; // Max Loss per Trade ($) input double InpInitialSL = 0.60; // Initial SL ($) input double InpTpMultiplier = 3.0; // TP = Nx SL Distance input double InpRollingSLMult = 1.5; // Rolling SL Divider input int InpDynamicTpPct = 50; // Dynamic TP Trigger (%) input bool InpUseDynamicTp = true; // Enable Dynamic TP input bool InpUseRollingSL = true; // Enable Rolling SL input double InpConfidenceThresh = 0.70; // Min Confidence to Trade input group "=== Drawdown Limits ===" input double InpDailyDDLimit = 4.5; // Daily DD Limit % input double InpMaxDDLimit = 9.0; // Max DD Limit %
Berechnung der festen Dollar-Lotgröße
Die Kernrisikoformel berechnet die genaue Lotgröße, die erforderlich ist, um bei der vorgegebenen Stop-Loss-Distanz genau 1,00 $ zu riskieren. Dies ist die wichtigste Funktion im gesamten System:
// CalculateLotSize - determines exact lot size to risk InpMaxLossDollars // symbol - the trading instrument (e.g. "BTCUSD") // slDistPoints - stop loss distance in price points // returns - lot size clamped to broker min/max limits double CalculateLotSize(string symbol, double slDistPoints) { // Query broker for instrument specifications at runtime double tickVal = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE); double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE); double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN); double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX); double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP); if(tickVal <= 0 || slDistPoints <= 0) return minLot; // (tickVal / tickSize) = dollar value per one point of price movement // So: slDistPoints * (tickVal / tickSize) = total dollar loss per lot // Dividing maxLoss by that gives the lot size for exact risk control // // Example: BTCUSD, SL = 50 points, tickVal = $0.01, tickSize = 0.01 // valuePerPoint = 0.01 / 0.01 = $1.00 per point per lot // dollarRisk = 50 * 1.00 = $50.00 per lot // lot = 1.00 / 50.00 = 0.02 lots -> risks exactly $1.00 double lot = InpMaxLossDollars / (slDistPoints * (tickVal / tickSize)); // Round DOWN to nearest lot step (never round up to avoid exceeding risk) lot = MathFloor(lot / lotStep) * lotStep; // Clamp to broker min/max volume limits if(lot < minLot) lot = minLot; if(lot > maxLot) lot = maxLot; return lot; }
Diese Funktion fragt den Broker zur Laufzeit nach dem Tick-Wert und der Tick-Größe ab und gewährleistet so eine korrekte Berechnung der Lotgröße für jedes Instrument. Die MathFloor-Rundung stellt sicher, dass wir unser Risikobudget niemals versehentlich durch Aufrundung überschreiten.
Sicherheitsprüfung für Drawdown-Grenzen
Vor jeder Handelsentscheidung vergleicht der EA sowohl den täglichen Drawdown als auch den maximalen Drawdown mit den Grenzwerten der Prop-Firma:
bool IsDrawdownSafe() { double equity = AccountInfoDouble(ACCOUNT_EQUITY); double balance = AccountInfoDouble(ACCOUNT_BALANCE); // Daily drawdown check double dailyDD = (g_dailyStartBalance - equity) / g_dailyStartBalance * 100.0; if(dailyDD >= InpDailyDDLimit) { Print("DAILY DD LIMIT REACHED: ", DoubleToString(dailyDD, 2), "%"); return false; } // Max drawdown check (from peak balance) if(balance > g_peakBalance) g_peakBalance = balance; double maxDD = (g_peakBalance - equity) / g_peakBalance * 100.0; if(maxDD >= InpMaxDDLimit) { Print("MAX DD LIMIT REACHED: ", DoubleToString(maxDD, 2), "%"); return false; } return true; }
Der tägliche Drawdown wird anhand des Kontostands zu Beginn des Handelstags berechnet. Der maximale Drawdown orientiert sich am Höchststand des Kontostands. Sobald einer der beiden Grenzwerte erreicht ist, gibt die Funktion false zurück, und der EA stellt alle Handelsaktivitäten ein, bis sich die Bedingungen wieder verbessern.
Positionsverwaltung: Teilschließung und rollierender Stop-Loss
Die Funktion ManagePositions implementiert das zweistufige Gewinnrealisierungssystem. Sie durchläuft alle offenen Positionen dieses EAs (gefiltert nach der Magic Number) und wendet dabei die Logik für dynamischen Take-Profit und rollierenden Stop-Loss an:
void ManagePositions() { for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket <= 0) continue; if(PositionGetInteger(POSITION_MAGIC) != InpMagic) continue; double openPrice = PositionGetDouble(POSITION_PRICE_OPEN); double curPrice = PositionGetDouble(POSITION_PRICE_CURRENT); double volume = PositionGetDouble(POSITION_VOLUME); long type = PositionGetInteger(POSITION_TYPE); // Calculate profit distance from entry double profitDist = 0; if(type == POSITION_TYPE_BUY) profitDist = curPrice - openPrice; else profitDist = openPrice - curPrice; double slDist = g_tracks[idx].initialSLDist; double tpDist = slDist * InpTpMultiplier; // Stage 1: Partial close at 50% of TP distance if(InpUseDynamicTp && !g_tracks[idx].partialClosed) { double trigger = tpDist * InpDynamicTpPct / 100.0; if(profitDist >= trigger) { // --- Simplified logic (full implementation in attached EA) --- // 1. Close half the position via OrderSend(TRADE_ACTION_DEAL) // 2. Move SL to breakeven (entry price) via OrderSend(TRADE_ACTION_SLTP) // 3. Set partialClosed = true to prevent repeat execution } } // Stage 2: Rolling SL tightens as price moves favorably if(InpUseRollingSL && profitDist > 0) { double newSLDist = slDist / InpRollingSLMult; // --- Simplified logic (full implementation in attached EA) --- // Calculate new SL price, only modify if tighter than current SL } } }
Der Mechanismus der teilweisen Glattstellung ist besonders wirkungsvoll für den Handel von Prop-Firmen. Indem man die Hälfte der Position bei 50 % des Take-Profit-Ziels schließt und den Stop auf Breakeven verschiebt, wird jeder gewinnbringende Trade, der diese Schwelle erreicht, zu einem garantierten Gewinn. Der verbleibende Free Runner kann bis zum vollständigen TP-Ziel oder darüber hinaus weiterlaufen, ohne dass das Risiko besteht, die erzielten Gewinne wieder abzugeben.
Ergebnisse und Überlegungen zur Leistung
Die Basisarchitektur ist seit Januar 2026 auf mehreren Konten von Prop-Firmen im Live-Betrieb im Einsatz. Zu den wichtigsten Leistungsmerkmalen gehören:
- Risiko pro Trade: genau 1,00 $, nie überschritten
- Kompressionsfilter: Schließt etwa 60–70 % der potenziellen Handelsgeschäfte aus und konzentriert sich ausschließlich auf strukturierte Marktbedingungen
- Quote der Teilgewinnmitnahmen: Etwa 40 % der gewinnbringenden Trades erreichen die 50-%-TP-Schwelle für einen Teilausstieg
- Einhaltung der Drawdown-Regeln: Keine Verstöße gegen die Vorschriften für Prop-Firmen auf allen Konten
- Skalierbarkeit der Architektur: Erfolgreicher gleichzeitiger Betrieb von mehr als 6 Konten mit unabhängiger Prozessisolierung
Die wichtigste Kennzahl ist die letzte: null Regelverstöße. Beim Handel mit Prop-Firmen hat das Überleben Vorrang vor der Rentabilität. Ein System, das es konsequent vermeidet, Drawdown-Grenzen zu überschreiten, wird Herausforderungen letztendlich meistern und kapitalgedeckte Konten aufrechterhalten, während ein profitableres System, das gelegentlich gegen die Regeln verstößt, alles verlieren wird.
Vollständiges EA-Gerüst
Das folgende Minimalbeispiel zeigt, wie alle oben beschriebenen Komponenten im Rahmen des Standard-Lebenszyklus eines MetaTrader 5-EAs miteinander verknüpft sind. Die vollständige Implementierung mit der gesamten Handelsausführungslogik ist in der beigefügten .mq5-Datei enthalten.
//+------------------------------------------------------------------+ //| Article_01_EA.mq5 | //| Neuro-Structural Trading Engine - Foundation | //+------------------------------------------------------------------+ #property copyright "QuantumChildren Trading Systems" #property version "1.00" input double InpMaxLossDollars = 1.00; // Max Loss per Trade ($) input double InpInitialSL = 0.60; // Initial SL ($) input double InpTpMultiplier = 3.0; // TP = Nx SL Distance input double InpDailyDDLimit = 4.5; // Daily DD Limit % input double InpMaxDDLimit = 9.0; // Max DD Limit % input int InpMagic = 212001;// Magic Number double g_dailyStartBalance, g_peakBalance; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { g_dailyStartBalance = AccountInfoDouble(ACCOUNT_BALANCE); g_peakBalance = g_dailyStartBalance; Print("Foundation EA initialized. Balance: $", DoubleToString(g_dailyStartBalance, 2)); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert tick function - main trading loop | //+------------------------------------------------------------------+ void OnTick() { // Step 1: Safety check - are we within prop firm drawdown limits? if(!IsDrawdownSafe()) return; // Step 2: Manage existing positions (partial close + rolling SL) ManagePositions(); // Step 3: Generate or read trading signal // (signal generation via indicators shown in attached EA) // Step 4: Calculate lot size for fixed dollar risk // double lots = CalculateLotSize(_Symbol, slDistance); // Step 5: Execute trade if signal passes all validation // (full execution logic in attached EA) } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { Print("Foundation EA stopped. Reason: ", reason); }
Testen im Strategietester
So testen Sie den angehängten EA im MetaTrader 5-Strategietester:
- Öffnen Sie den MetaEditor (F4) und kompilieren Sie die angehängte Datei Article_01_EA.mq5 (F7).
- Öffnen Sie in MetaTrader 5 das Fenster Strategietester (Strg+R).
- Wählen Sie den kompilierten EA aus der Dropdown-Liste Expert Advisor aus.
- Stellen Sie das Symbol auf BTCUSD und den Zeitrahmen auf M1 (1 Minute) ein.
- Stellen Sie das Testmodell auf „Jeder Tick basierend auf echten Ticks“ ein, um maximale Genauigkeit zu erzielen.
- Stellen Sie den Datumsbereich so ein, dass er mindestens einen Monat aktueller Daten umfasst.
- Legen Sie die Ersteinzahlung entsprechend der Höhe Ihres Kontos bei der Prop-Firma fest (z. B. 100.000 $).
- Klicken Sie auf Start, um den Backtest auszuführen.
Wichtige Parameter, die vor dem Ausführen auf der Registerkarte mit den Einstellungen überprüft werden müssen:
| Parameter | Standard | Beschreibung |
|---|---|---|
| InpMaxLossDollars | 1.00 | Maximales Dollar-Risiko pro Handel |
| InpInitialSL | 0.60 | Anfänglicher Stop-Loss-Abstand in Dollar |
| InpTpMultiplier | 3.0 | Take-Profit als Vielfaches der SL-Distanz |
| InpDailyDDLimit | 4.5 | Schwellenwert für die Unterbrechung des täglichen Drawdowns (%) |
| InpMaxDDLimit | 9.0 | Schwellenwert für die Stop-Loss-Auslösung bei maximalem Drawdown (%) |
Nachdem der Test abgeschlossen ist, sehen Sie sich die Registerkarten Ergebnisse, Diagramm und Bericht an. Die Kapitalkurven sollten kontrollierte Drawdowns aufweisen, die mit dem festen Risiko von 1,00 $ pro Trade im Einklang stehen.
Abbildung 4. Bericht des Strategietesters. Backtest-Ergebnisse für BTCUSD M1 mit Handelsstatistiken, Gewinnfaktor und Drawdown-Kennzahlen
Abbildung 5. Kapitalkurven. Die Kontostände und das Eigenkapital im Backtest-Zeitraum zeigen kontrollierte Drawdowns, die mit einem festen Risiko von 1,00 $ pro Trade im Einklang stehen
Verwendung- Öffnen Sie die angehängte .mq5-Datei im MetaEditor und drücken Sie F7, um sie zu kompilieren.
- Öffnen Sie in MetaTrader 5 den Navigator (Strg+N), suchen Sie den EA unter Expert Advisors und ziehen Sie ihn auf ein M1-Chart für BTCUSD oder XAUUSD.
- Konfigurieren Sie im Dialogfeld EA-Eigenschaften die Eingabeparameter entsprechend den Risikoregeln Ihres Kontos. Überprüfen Sie zumindest die Parameter InpMaxLossDollars, InpDailyDDLimit und InpMaxDDLimit.
- Klicken Sie in der Symbolleiste von MetaTrader 5 auf die Schaltfläche AutoTrading, um den algorithmischen Handel zu aktivieren.
- Starten Sie die Python-Signal-Engine in einem separaten Terminalfenster, damit der EA die Signaldateien lesen kann.
- Behalten Sie die Registerkarte Experten am unteren Rand von MetaTrader 5 im Auge, um Protokolle zur Handelsausführung und Statusmeldungen zu Signalen zu verfolgen.
Empfohlener Zeitrahmen: M1 (1 Minute). Der EA liest Signale aus, die vom Python-Backend in Abständen von 60 Sekunden generiert werden.
Was Sie jetzt haben
Nachdem Sie diesen Artikel gelesen haben, stehen Ihnen die folgenden konkreten Artefakte zur Verfügung:
- Ein Prozessarchitekturdiagramm – ein spezielles Python-Skript und ein spezielles MetaTrader-5-Terminal pro Konto der Prop-Firma, ohne dass zwischen ihnen ein gemeinsamer Status besteht.
- Eine Funktion zur Festlegung der Lotgröße in Dollar (CalculateLotSize) – fügen Sie diese in einen beliebigen EA ein, um sicherzustellen, dass kein einzelner Trade mehr als den von Ihnen festgelegten Dollarbetrag verlieren kann, unabhängig von der Volatilität des Instruments.
- Ein auf Kompression basierender Regime-Filter – drei Logikregeln, die prüfen, ob der aktuelle Markt eine nutzbare Struktur aufweist, und so 60–70 % der Verlusttrades unter unruhigen Marktbedingungen ausschließen.
- Eine Drawdown-Sicherheitsprüfung (IsDrawdownSafe) – rufen Sie diese vor jeder Handelsentscheidung auf, um sicherzustellen, dass Sie niemals das tägliche oder maximale Drawdown-Limit Ihrer Prop-Firma überschreiten.
- Ein zweistufiges Gewinnmitnahmesystem – Teilausstieg bei 50 % des Kursziels plus rollierender Stop-Loss, wodurch gewinnbringende Trades mithilfe eines Free-Runner in garantierte Gewinne umgewandelt werden.
- Ein vollständiges EA-Grundgerüst – kompilieren Sie die beigefügte .mq5-Datei im MetaEditor, fügen Sie sie einem Chart hinzu und testen Sie sie sofort im Strategietester.
Fünf Parameter, die Sie nicht ändern sollten, ohne die Folgen zu kennen:
- InpMaxLossDollars — Eine Erhöhung dieses Wertes vervielfacht Ihren schlimmsten Verlust pro Trade
- InpDailyDDLimit — Wenn Sie diesen Wert über das tatsächliche Tageslimit Ihrer Prop-Firma einstellen, wird Ihr Konto gekündigt.
- InpMaxDDLimit — wie oben für den maximalen Drawdown
- InpTpMultiplier — Werte unter 2,0 beeinträchtigen das Risiko-Ertrags-Verhältnis, das die Rentabilität des Systems gewährleistet
- InpDynamicTpPct — Wird dieser Wert zu hoch eingestellt, werden Teilschließungen nur selten ausgelöst, wodurch der Mechanismus für garantierte Gewinne außer Kraft gesetzt wird.
Erfolgskriterien beim Testen im Strategietester: Der Backtest sollte zeigen, dass kein einzelner Trade mehr als InpMaxLossDollars verliert, der tägliche Drawdown niemals InpDailyDDLimit Prozent überschreitet und die Kapitalkurven kontrollierte, flache Drawdowns statt steiler vertikaler Einbrüche aufweist.
Schlussfolgerung
Diese Grundlage umfasst fünf Kernkompetenzen, auf denen jeder nachfolgende Artikel dieser Reihe aufbaut:
- Ein festes Dollar-Risiko, das katastrophale Verluste unabhängig von der Marktvolatilität verhindert
- Erkennung strukturierter Marktregime anhand des Kompressionsverhältnisses, um unruhige, unrentable Märkte zu meiden
- Intelligenz durch LSTM-Netze zur Richtungsvorhersage mit Konfidenzbewertung
- Zweistufige Gewinnmitnahme durch Teilglattstellung und rollierenden Stop-Loss
- In jeden Entscheidungszyklus integrierte Sicherheitsgrenzen für Prop-Firmen
Das System läuft gleichzeitig auf mehr als sechs Konten von Prop-Firmen, wobei jedes Konto über einen eigenen dedizierten Prozess und ein eigenes MetaTrader-5-Terminal verfügt. Die zentralisierte Konfiguration stellt sicher, dass alle Konten dieselben Risikoparameter verwenden, ohne dass fest codierte Werte in die Ausführungsskripte gelangen.
Im nächsten Artikel stellen wir Jardine’s Gate vor – den Quantenfilter mit sechs Gattern, der zwischen der Signalerzeugung und der Handelsausführung angesiedelt ist. Dieser Filter führte zu einer bemerkenswerten Verbesserung der Handelsqualität, da Signale sechs unabhängige Validierungsstufen durchlaufen müssen, bevor eine Ausführung zugelassen wird.
Der vollständige Quellcode des Expert Advisors, der alle in diesem Artikel behandelten Funktionen implementiert, steht im Anhang zum Download bereit. Es lässt sich direkt in MetaEditor 5 kompilieren und kann zum Testen im Strategietester an jedes Chart angehängt werden.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/21372
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.
Erstellen benutzerdefinierter Indikatoren in MQL5 (Teil 7): Hybride Time-Price-Opportunity-(TPO)-Marktprofile für die Analyse von Handelssitzungen
Swing-Extreme und Rücksetzer in MQL5 (Teil 1): Entwicklung eines Multi-Timeframe-Indikators
Eine alternative Log-datei mit der Verwendung der HTML und CSS
MQL5-Handelswerkzeuge (Teil 21): Hinzufügen eines Cyberpunk-Theme zu Regressionsdiagrammen
- 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.