Forex-EA auf Basis des N-BEATS-Netzwerks
Moderne Forex-Handelsroboter verwenden immer noch Indikatoren von vor zwanzig Jahren. Die gleitenden Durchschnitte kreuzen sich, der RSI liegt über 70, der MACD hat nach unten gedreht – und der Roboter entscheidet, Millionen von Dollar zu kaufen oder zu verkaufen. Es klingt absurd, aber so funktionieren die meisten Expert Advisors (EAs).
Finanzmärkte weisen entscheidende Merkmale auf, die klassische Ansätze außer Acht lassen. Das Signal-Rausch-Verhältnis beträgt etwa 1:10 – neun Zehntel aller Kursbewegungen sind zufällige Schwankungen. Langzeitabhängigkeiten spielen eine entscheidende Rolle: Entscheidungen der Europäischen Zentralbank, die vor einem Monat getroffen wurden, können sich noch heute auf den EUR-Wechselkurs auswirken, doch klassische Indikatoren berücksichtigen dies nicht.
Die Nichtstationarität der Märkte führt zu weiteren Komplikationen. Muster, die vor einem Monat noch funktioniert haben, können aufgrund von Veränderungen der makroökonomischen Lage oder des Verhaltens wichtiger Akteure an Bedeutung verlieren. Jedes Handelssystem muss in der Lage sein, sich an diese Veränderungen anzupassen.
Aus diesem Grund haben wir uns für die N-BEATS-Architektur entschieden – einen revolutionären Ansatz für die Zeitreihenprognose, der speziell für die Behandlung komplexer zeitlicher Abhängigkeiten entwickelt wurde.
N-BEATS: Ein architektonischer Durchbruch in der Zeitreihenanalyse
Forscher von Element AI schlugen bereits 2019 einen grundlegend neuen Ansatz für Prognosen vor. Anstatt bestehende RNN- oder CNN-Architekturen anzupassen, stellten sie eine grundlegende Frage: Welche Architektur eignet sich am besten für Prognoseaufgaben?
N-BEATS basiert auf dem Prinzip der Zeitreihenzerlegung. Stellen Sie sich eine musikalische Komposition vor: Anstatt zu versuchen, die nächste Note anhand des Gesamtklangs vorherzusagen, analysieren wir Melodie, Rhythmus und Harmonie getrennt voneinander und führen die Ergebnisse anschließend zu einer Vorhersage zusammen. In ähnlicher Weise zerlegt N-BEATS die Zeitreihe in Trend, saisonale Schwankungen und residuale Muster.
Die Architektur nutzt Residual Learning, bei dem jeder Block nicht nur eine Prognose für die Zukunft erstellt, sondern auch den bisherigen Verlauf der Zeitreihe erklärt. Ist die Erklärung ungenau, wird der Fehler an den nächsten Block weitergeleitet. Es erinnert an eine kriminalistische Ermittlung: Jeder Ermittler erläutert einen Teil der Beweislage und leitet ungeklärte Fragen an einen Kollegen weiter.
Der entscheidende Vorteil von N-BEATS ist die Interpretierbarkeit. Im Gegensatz zur „Black Box“ herkömmlicher neuronaler Netze lässt sich anhand dieser Architektur erkennen, welche Rolle der Trend bei der Prognose spielt und welchen Einfluss saisonale Schwankungen haben. Für einen Trader bedeutet dies, nicht nur zu verstehen, was passieren wird, sondern auch warum.
Die Ergebnisse der Tests anhand gängiger Benchmarks versetzten die wissenschaftliche Gemeinschaft in Erstaunen. N-BEATS übertraf alle bisherigen Methoden, darunter LSTM-Netzwerke und Transformer-Architekturen. Besonders beeindruckend ist, dass dies ausschließlich anhand historischer Daten aus der Zeitreihe selbst gelang, ohne externe Merkmale.
Im Gegensatz zu RNNs kann N-BEATS die Eingabesequenz parallel statt streng sequenziell verarbeiten. Für den algorithmischen Handel bedeutet dies die Möglichkeit, in Märkten mit schnellen Kursbewegungen Prognosen in Echtzeit zu erstellen.
Die Anpassung der akademischen Architektur an die chaotische Welt der Forex-Märkte erfordert jedoch erhebliche Änderungen. Es sind Quantilprognosen (anstelle von Punktschätzungen), multivariate Eingabedaten und eine spezielle Behandlung von Marktrauschen erforderlich.
Grundlegender Aufbau einer Matrix mit Gradienten
MetaTrader 5 bietet keine vorgefertigten Tools für maschinelles Lernen, daher muss alles von Grund auf neu entwickelt werden. Unser System basiert auf einer Struktur namens Matrix, die neben den Daten auch die Gradienten für jedes Element speichert:
struct Matrix { double data[]; double gradients[]; // Key complement for backprop int rows, cols; void Init(int r, int c) { rows = r; cols = c; ArrayResize(data, r * c); ArrayResize(gradients, r * c); ArrayInitialize(data, 0.0); ArrayInitialize(gradients, 0.0); } double Get(int r, int c) { if(r < 0 || r >= rows || c < 0 || c >= cols) return 0.0; return data[r * cols + c]; } void AddGrad(int r, int c, double grad) { if(r < 0 || r >= rows || c < 0 || c >= cols) return; gradients[r * cols + c] += grad; // Accumulation of gradients } void ZeroGrad() { ArrayInitialize(gradients, 0.0); // Zeroing before a new iteration } };
Diese Struktur ermöglicht es jeder Schicht des Netzwerks, Gradienten automatisch zu akkumulieren und an die vorhergehenden Schichten weiterzugeben.
Die SiLU-Funktion wird zur Aktivierung von Neuronen verwendet und liefert bei Finanzdaten im Vergleich zur klassischen ReLU-Funktion bessere Ergebnisse. Für eine korrekte Fehlerrückpropagation ist es wichtig, nicht nur die Funktion selbst, sondern auch ihre Ableitung zu implementieren.// SiLU (Swish) activation is smoother than ReLU double SiLU(double x) { double sig = 1.0 / (1.0 + MathExp(-MathMin(MathMax(x, -50), 50))); return x * sig; } double SiLUDerivative(double x) { double sig = 1.0 / (1.0 + MathExp(-MathMin(MathMax(x, -50), 50))); return sig * (1.0 + x * (1.0 - sig)); } // Sigmoid for the output layer double Sigmoid(double x) { return 1.0 / (1.0 + MathExp(-MathMin(MathMax(x, -50), 50))); } double SigmoidDerivative(double x) { double s = Sigmoid(x); return s * (1.0 - s); }
Die Begrenzung der Eingabewerte auf den Bereich von -50 bis 50 verhindert einen Überlauf bei der Berechnung des Exponenten, was für die Stabilität des Trainings anhand verrauschter Finanzdaten von entscheidender Bedeutung ist.
Der einfache Gradientenabstieg funktioniert bei Finanzzeitreihen aufgrund des hohen Rauschanteils nicht gut. Daher wird ein Adam-Optimierer implementiert, der die Lernrate für jeden Parameter auf der Grundlage des Gradientenverlaufs adaptiv anpasst.
struct AdamOptimizer { Matrix m, v; // Momentum and speed double beta1, beta2, eps; int step; void Init(int rows, int cols) { m.Init(rows, cols); v.Init(rows, cols); beta1 = 0.9; beta2 = 0.999; eps = 1e-8; step = 0; } void Update(Matrix &weights, double lr, double weight_decay = 0.01) { step++; for(int i = 0; i < weights.rows; i++) { for(int j = 0; j < weights.cols; j++) { double grad = weights.GetGrad(i, j) + weight_decay * weights.Get(i, j); // Update moments double m_val = beta1 * m.Get(i, j) + (1 - beta1) * grad; double v_val = beta2 * v.Get(i, j) + (1 - beta2) * grad * grad; m.Set(i, j, m_val); v.Set(i, j, v_val); // Bias correction double m_hat = m_val / (1 - MathPow(beta1, step)); double v_hat = v_val / (1 - MathPow(beta2, step)); // Update weights double update = lr * m_hat / (MathSqrt(v_hat) + eps); weights.Set(i, j, weights.Get(i, j) - update); } } weights.ZeroGrad(); // Clear gradients after updating } };
Vorwärts- und Rückwärtsdurchläufe im N-BEATS-Block
Jeder N-BEATS-Block führt eine komplexe Abfolge von Operationen aus. Es ist unerlässlich, Zwischenwerte für den Rückwärtsdurchlauf zu speichern:
struct NBeatsBlock { Matrix fc1_w, fc1_b, fc2_w, fc2_b, theta_projection; AdamOptimizer fc1_opt, fc2_opt, theta_opt; // Intermediate values for backprop Matrix fc1_input, fc1_output, fc2_input, fc2_output; void Forward(Matrix &input_patch, Matrix &backcast, Matrix &forecast) { // Save the input for backprop fc1_input.Copy(input_patch); // FC1 layer fc1_output.Init(1, HIDDEN_SIZE); for(int j = 0; j < HIDDEN_SIZE; j++) { double s = 0.0; for(int i = 0; i < input_patch.cols; i++) s += input_patch.Get(0, i) * fc1_w.Get(i, j); s += fc1_b.Get(0, j); fc1_output.Set(0, j, s); // Save BEFORE activation } // Activation with saving for backprop fc2_input.Init(1, HIDDEN_SIZE); for(int j = 0; j < HIDDEN_SIZE; j++) { fc2_input.Set(0, j, SiLU(fc1_output.Get(0, j))); } // Similar for FC2 layer... // Theta projection and backcast/forecast generation } void Backward(Matrix &backcast_grad, Matrix &forecast_grad) { // Backprop starts with output gradients // Combine backcast and forecast gradients Matrix theta_grad; theta_grad.Init(1, theta_projection.cols); // Calculate theta projection gradients for(int i = 0; i < theta_projection.cols; i++) { double grad = 0.0; if(i < backcast_size) { grad += backcast_grad.GetGrad(0, i); } else { grad += forecast_grad.GetGrad(0, i - backcast_size); } theta_grad.SetGrad(0, i, grad); } // Backprop via theta projection к FC2 Matrix fc2_grad; fc2_grad.Init(1, HIDDEN_SIZE); for(int i = 0; i < HIDDEN_SIZE; i++) { double grad_sum = 0.0; for(int j = 0; j < theta_projection.cols; j++) { grad_sum += theta_grad.GetGrad(0, j) * theta_projection.Get(i, j); // Accumulate gradients for the theta_projection weights theta_projection.AddGrad(i, j, theta_grad.GetGrad(0, j) * fc2_output.Get(0, i)); } fc2_grad.SetGrad(0, i, grad_sum); } // Backprop via SiLU activation Matrix fc2_input_grad; fc2_input_grad.Init(1, HIDDEN_SIZE); for(int i = 0; i < HIDDEN_SIZE; i++) { double grad = fc2_grad.GetGrad(0, i) * SiLUDerivative(fc1_output.Get(0, i)); fc2_input_grad.SetGrad(0, i, grad); } // Backprop through FC1 layer to inputs // ... similar calculations for all layers } };
Quantilverlustfunktion
Um die Unsicherheit vorherzusagen, verwenden wir anstelle des üblichen MSE den Quantilverlust:
void Train(double &time_series[], double target) { step_count++; // Forward pass for all quantiles double predictions[QUANTILE_LEVELS]; Predict(time_series, predictions); // Calculate quantile losses for(int q = 0; q < QUANTILE_LEVELS; q++) { double pred = predictions[q]; double error = target - pred; double quantile = quantiles[q]; // 0.1, 0.5, 0.9 // Quantile loss double loss_weight = (error >= 0) ? quantile : (1.0 - quantile); double focal_weight = class_weights.GetFocalWeight(target, pred); double loss = focal_weight * loss_weight * MathAbs(error); // Gradient for quantile loss double grad_wrt_pred = focal_weight * loss_weight * ((error >= 0) ? -1.0 : 1.0); double grad_wrt_logit = grad_wrt_pred * SigmoidDerivative(pred); // Backprop to output weights for(int h = 0; h < HIDDEN_SIZE; h++) { double grad = grad_wrt_logit * pooled_features[h]; output_proj[q].SetGrad(h, 0, grad); } } // Run a backward pass through the entire network BackpropagateToAllLayers(); // Update the weights of all layers UpdateAllWeights(); }
Die Qualität der Eingabedaten ist entscheidend für den Erfolg jedes Modells des maschinellen Lernens, doch bei Handelsalgorithmen kann sie den Unterschied zwischen dem Erhalt und dem vollständigen Verlust des Kontoguthabens ausmachen.
Multivariate Merkmale
Anstelle einer einfachen Abfolge von Schlusskursen verwenden wir eine Vielzahl von Merkmalen:
void PrepareInputData(MqlRates &rates[], double &input_data[], int input_bars) { ArrayResize(input_data, input_bars * 2); // 2 features per bar for(int i = 0; i < input_bars; i++) { if(i < ArraySize(rates) - 1) { // Feature 1: Normalized price change double price_change = (rates[i].close - rates[i].open) / rates[i].open; input_data[i * 2] = MathMax(-1.0, MathMin(1.0, price_change * 100)); // Feature 2: Logarithmically normalized volume double vol_ratio = (rates[i].tick_volume > 0) ? MathLog(1.0 + rates[i].tick_volume / 1000.0) : 0.0; input_data[i * 2 + 1] = MathMax(0.0, MathMin(1.0, vol_ratio / 10.0)); } else { input_data[i * 2] = 0.0; input_data[i * 2 + 1] = 0.0; } } }
Die Begrenzung der Werte auf sinnvolle Bereiche verhindert, dass extreme Ausreißer das Modelltraining beeinflussen.
Robuste Normalisierung bei verrauschten Daten
Finanzdaten sind voller Anomalien: Kurssprünge, technische Störungen, ungewöhnliche Handelsvolumina. Eine einfache Min-Max-Normalisierung kann bereits durch einen einzigen Ausreißer verfälscht werden:
void RobustNormalization(double &data[], int window_size = 200) { int data_size = ArraySize(data); for(int i = window_size; i < data_size; i++) { // Calculate robust statistics for a sliding window double window_data[]; ArrayResize(window_data, window_size); for(int j = 0; j < window_size; j++) { window_data[j] = data[i - window_size + j]; } // Median instead of mean (robust to outliers) ArraySort(window_data); double median = window_data[window_size / 2]; // MAD (Median Absolute Deviation) instead of standard deviation double deviations[]; ArrayResize(deviations, window_size); for(int j = 0; j < window_size; j++) { deviations[j] = MathAbs(window_data[j] - median); } ArraySort(deviations); double mad = deviations[window_size / 2]; // Robust normalization if(mad > 1e-8) { data[i] = MathMax(-3.0, MathMin(3.0, (data[i] - median) / mad)); } } }
Die Verwendung des Medians und der MAD anstelle des Mittelwerts und der Standardabweichung macht die Normalisierung robust gegenüber Ausreißern.
Erkennung und Behandlung von Anomalien
Das System sollte ungewöhnliche Marktbedingungen automatisch erkennen:
bool DetectMarketAnomaly(MqlRates &rates[], int lookback = 50) { if(ArraySize(rates) < lookback) return false; // Calculate volatility for the period double volatilities[]; ArrayResize(volatilities, lookback); for(int i = 1; i < lookback; i++) { double change = MathAbs(rates[i].close - rates[i-1].close) / rates[i-1].close; volatilities[i] = change; } ArraySort(volatilities); double median_vol = volatilities[lookback / 2]; double vol_95 = volatilities[(int)(lookback * 0.95)]; // Current volatility double current_vol = MathAbs(rates[0].close - rates[1].close) / rates[1].close; // Anomaly if current volatility exceeds 95th percentile 2+ times return (current_vol > vol_95 * 2.0); }Werden Anomalien erkannt, kann das Handelssystem die Positionsgrößen vorübergehend reduzieren oder den Handel aussetzen.
Herkömmliche Prognoseansätze liefern eine einzige Punktschätzung – der Preis wird diesen oder jenen Wert annehmen. Für den Handel ist es jedoch entscheidend, die Unsicherheit der Prognose zu verstehen. Aus diesem Grund nutzt unsere Implementierung von N-BEATS die Quantilprognose.
Anstelle eines einzigen Wertes liefert das System drei Schätzwerte: ein pessimistisches Szenario (0,1-Quantil), eine realistische Prognose (Median) und ein optimistisches Szenario (0,9-Quantil). Die Differenz zwischen den Quantilen zeigt, wie sicher sich das Modell seiner Prognose ist.
Für das Training des Modells zur Erstellung von Quantilprognosen wird eine spezielle Verlustfunktion verwendet, die Unter- und Überschätzungen je nach Zielquantil unterschiedlich bestraft.
void ProcessQuantilePredictions(double &predictions[]) { double q10 = predictions[0]; // Pessimistic scenario double q50 = predictions[1]; // Median forecast double q90 = predictions[2]; // Optimistic scenario // Calculate the model uncertainty double uncertainty = q90 - q10; double confidence = 1.0 - MathMin(1.0, uncertainty / 0.4); // Normalize [0,1] // Dynamically adjust position size double base_lot = CalculateBaseLotSize(); double adjusted_lot = base_lot * confidence; if(q50 > 0.65 && uncertainty < 0.2) { // High growth confidence, low uncertainty OpenPosition(ORDER_TYPE_BUY, adjusted_lot * 1.5, "High confidence"); } else if(q50 > 0.6 && uncertainty < 0.3) { // Moderate confidence in growth OpenPosition(ORDER_TYPE_BUY, adjusted_lot, "Medium confidence"); } else if(q10 > 0.55) { // Even the pessimistic scenario shows growth OpenPosition(ORDER_TYPE_BUY, adjusted_lot * 0.7, "Conservative long"); } Print("Uncertainty: ", DoubleToString(uncertainty, 3), " | Confidence: ", DoubleToString(confidence, 3), " | Adjusted lot: ", DoubleToString(adjusted_lot, 2)); }
Focal Loss: Bekämpfung von Klassenungleichgewichten
Auf den Finanzmärkten treten unterschiedliche Bewegungen ungleich häufig auf: Phasen ruhigen Handels wechseln sich mit seltenen, aber starken Kursbewegungen ab. Die Standard-Verlustfunktion kann dieses Problem nicht lösen, daher verwenden wir Focal Loss:
struct ClassWeights { double strong_bull, weak_bull, neutral, weak_bear, strong_bear; void UpdateWeights(int &counts[]) { int total = counts[0] + counts[1] + counts[2] + counts[3] + counts[4]; if(total == 0) return; // Inverted weights - rare classes get more weight strong_bear = (counts[0] > 0) ? (double)total / (5 * counts[0]) : 1.0; weak_bear = (counts[1] > 0) ? (double)total / (5 * counts[1]) : 1.0; neutral = (counts[2] > 0) ? (double)total / (5 * counts[2]) : 1.0; weak_bull = (counts[3] > 0) ? (double)total / (5 * counts[3]) : 1.0; strong_bull = (counts[4] > 0) ? (double)total / (5 * counts[4]) : 1.0; } double GetFocalWeight(double target, double pred) { double alpha = GetClassWeight(target); double pt = (target > 0.5) ? pred : (1.0 - pred); // Focal Loss: focuses on difficult samples return alpha * MathPow(MathMax(1.0 - pt, 1e-8), FOCAL_GAMMA); } };
Focal Loss richtet die Aufmerksamkeit automatisch stärker auf seltene, aber wichtige Marktereignisse – nämlich jene, bei denen Sie am meisten Geld verdienen können.
Unsicherheitsbasierter adaptiver Stop-Loss
Der traditionelle Ansatz bei Stop-Loss-Aufträgen ist simpel: Sie werden in einem festen Abstand zum Einstiegskurs platziert, der in Punkten angegeben wird. Unser System nutzt die prognostizierte Unsicherheit:
double CalculateAdaptiveStopLoss(double entry_price, ENUM_ORDER_TYPE order_type, double uncertainty, double base_sl_points = 500) { // Increase stop loss when uncertainty is high double uncertainty_multiplier = 1.0 + uncertainty * 2.0; // [1.0, 3.0] double adaptive_sl_points = base_sl_points * uncertainty_multiplier; // Take into account the current volatility double atr = CalculateATR(14); // Average True Range for 14 periods double volatility_adjustment = MathMax(0.5, MathMin(2.0, atr / (Point() * 100))); adaptive_sl_points *= volatility_adjustment; double sl_price; if(order_type == ORDER_TYPE_BUY) { sl_price = entry_price - adaptive_sl_points * Point(); } else { sl_price = entry_price + adaptive_sl_points * Point(); } Print("Adaptive SL: base=", base_sl_points, " uncertainty_mult=", DoubleToString(uncertainty_multiplier, 2), " volatility_adj=", DoubleToString(volatility_adjustment, 2), " final=", DoubleToString(adaptive_sl_points, 0)); return sl_price; } double CalculateATR(int period) { double atr_values[]; if(CopyBuffer(iATR(Symbol(), Period(), period), 0, 0, 1, atr_values) <= 0) { return Point() * 100; // Fallback value } return atr_values[0]; }
Integration mit der Handelslogik von MetaTrader 5
Ein leistungsfähiges neuronales Netzwerk zu entwickeln, ist erst die halbe Miete. Das Hauptziel besteht darin, das neuronale Netzwerk in die Handelsplattform zu integrieren, sodass es in Echtzeit arbeitet, jeden Tick verarbeitet und Handelsentscheidungen innerhalb von Millisekunden trifft.
MetaTrader 5 arbeitet nach einem ereignisgesteuerten Modell. Bei jedem Tick und jeder Kursänderung wird die Funktion OnTick() aufgerufen. Es ist jedoch ineffizient, bei jedem Tick aufwendige Berechnungen mit neuronalen Netzen durchzuführen – daher ist ein intelligentes Caching-System erforderlich:
datetime g_last_bar_time = 0; double g_cached_prediction = 0.5; bool g_prediction_valid = false; bool IsNewBar() { datetime current_bar_time = iTime(Symbol(), Period(), 0); if(current_bar_time != g_last_bar_time) { g_last_bar_time = current_bar_time; g_prediction_valid = false; // Cache is out of date return true; } return false; } void OnTick() { if(!g_net_initialized) return; // Perform light operations on every tick if(UseTrailingStop) UpdateTrailingStops(); // Heavy calculations only on the new bar if(IsNewBar()) { double prediction = GetAIPrediction(); // Computationally expensive operation g_cached_prediction = prediction; g_prediction_valid = true; ProcessTradingSignals(prediction); } // Check emergency exits on every tick if(g_prediction_valid) { CheckEmergencyExits(g_cached_prediction); } }Hysterese-Signalsystem
Die einfache Logik „oberhalb des Schwellenwerts – kaufen, darunter – verkaufen“ führt zum Problem des Signalflatterns. Wenn die Prognose um den Schwellenwert schwankt, öffnet und schließt das System kontinuierlich Positionen. Die Lösung ist die Hysterese:
void ProcessTradingSignalsWithHysteresis(double prediction) { static double last_prediction = 0.5; static datetime last_signal_time = 0; // Minimum interval between signals if(TimeCurrent() - last_signal_time < PeriodSeconds(Period()) * 2) return; int current_positions = CountPositions(); bool currently_long = HasLongPosition(); bool currently_short = HasShortPosition(); // Different thresholds for entry and exit (hysteresis) double long_entry_threshold = 0.70; double long_exit_threshold = 0.55; double short_entry_threshold = 0.30; double short_exit_threshold = 0.45; // Logic with hysteresis if(!currently_long && prediction > long_entry_threshold && last_prediction <= long_entry_threshold) { if(currently_short) CloseAllPositions("Signal reversal"); OpenPosition(ORDER_TYPE_BUY, prediction); last_signal_time = TimeCurrent(); Print("🚀 LONG ENTRY: ", DoubleToString(prediction, 3)); } else if(currently_long && prediction < long_exit_threshold && last_prediction >= long_exit_threshold) { CloseAllPositions("Long exit signal"); Print("📤 LONG EXIT: ", DoubleToString(prediction, 3)); } // Similar logic for short positions... last_prediction = prediction; }Kontinuierliches Training in der Produktivumgebung
Die Märkte entwickeln sich ständig weiter. Ein Modell, das vor einem Monat noch gut funktioniert hat, kann heute schon nutzlos sein. Daher ist ein System für kontinuierliches Lernen erforderlich:
struct ContinuousLearning { datetime last_retrain_time; double performance_buffer[]; int performance_window; double performance_threshold; void Init() { last_retrain_time = TimeCurrent(); performance_window = 100; // Track the last 100 trades performance_threshold = 0.45; // Degradation threshold ArrayResize(performance_buffer, performance_window); } void AddTradeResult(double prediction, double actual_outcome) { // Shift the buffer for(int i = 0; i < performance_window - 1; i++) { performance_buffer[i] = performance_buffer[i + 1]; } // Add a new result (1.0 = accurate prediction, 0.0 = completely wrong) double accuracy = 1.0 - MathAbs(prediction - actual_outcome); performance_buffer[performance_window - 1] = accuracy; // Check if retraining is necessary if(ShouldRetrain()) { ScheduleRetraining(); } } bool ShouldRetrain() { // Condition 1: Enough time has passed bool time_condition = (TimeCurrent() - last_retrain_time) > 24 * 3600; // Condition 2: Performance has decreased double avg_performance = 0.0; for(int i = 0; i < performance_window; i++) { avg_performance += performance_buffer[i]; } avg_performance /= performance_window; bool performance_condition = avg_performance < performance_threshold; return time_condition || performance_condition; } void ScheduleRetraining() { Print("🔄 Scheduling model retraining..."); Print("Average performance: ", DoubleToString(GetAveragePerformance(), 3)); // Retrain in a separate thread (simulate) RetrainModel(); last_retrain_time = TimeCurrent(); } }; ContinuousLearning g_learning_system;
N-BEATS ist eine komplexe Architektur mit vielen Parametern. In einer Produktivumgebung kann jede Millisekunde Latenz Geld kosten, daher ist die Leistungsoptimierung von entscheidender Bedeutung.
SpeicherverwaltungJede Matrix im Netzwerk kann Tausende von Parametern enthalten. Ohne eine ordnungsgemäße Speicherverwaltung gehen dem System schnell die Ressourcen aus:
struct MemoryManager { Matrix temp_matrices[]; int allocated_count; int max_temp_matrices; void Init() { max_temp_matrices = 100; ArrayResize(temp_matrices, max_temp_matrices); allocated_count = 0; } Matrix* AllocateTempMatrix(int rows, int cols) { if(allocated_count >= max_temp_matrices) { Print("⚠️ Temporary matrix pool exhausted!"); return NULL; } temp_matrices[allocated_count].Init(rows, cols); return &temp_matrices[allocated_count++]; } void ResetTempPool() { // Quick "release" without real deallocation allocated_count = 0; } void PrintMemoryUsage() { int total_elements = 0; for(int i = 0; i < allocated_count; i++) { total_elements += temp_matrices[i].rows * temp_matrices[i].cols; } double memory_mb = total_elements * sizeof(double) / (1024.0 * 1024.0); Print("Memory usage: ", DoubleToString(memory_mb, 2), " MB"); Print("Active matrices: ", allocated_count); } }; MemoryManager g_memory_manager;Profiling des kritischen Pfades
Es ist wichtig zu wissen, wo genau im Programm die Ausführungszeit anfällt:
struct Profiler { string operation_names[]; ulong operation_times[]; int operation_counts[]; int num_operations; void Init() { num_operations = 0; ArrayResize(operation_names, 50); ArrayResize(operation_times, 50); ArrayResize(operation_counts, 50); } void StartTimer(string operation) { // MQL5 does not have high-precision timers, use GetMicrosecondCount() ulong start_time = GetMicrosecondCount(); // Search for an existing operation or create a new one int index = FindOrCreateOperation(operation); operation_times[index] = start_time; } void EndTimer(string operation) { ulong end_time = GetMicrosecondCount(); int index = FindOperation(operation); if(index >= 0) { ulong elapsed = end_time - operation_times[index]; operation_times[index] = elapsed; // Reuse to store time operation_counts[index]++; } } void PrintReport() { Print("=== PERFORMANCE REPORT ==="); for(int i = 0; i < num_operations; i++) { double avg_time_ms = operation_times[i] / (double)operation_counts[i] / 1000.0; Print(operation_names[i], ": ", DoubleToString(avg_time_ms, 3), " ms avg, ", operation_counts[i], " calls"); } } }; Profiler g_profiler; // Usage: void OptimizedPredict(double &time_series[]) { g_profiler.StartTimer("PatchEmbedding"); // ... patch embedding code g_profiler.EndTimer("PatchEmbedding"); g_profiler.StartTimer("StackForward"); // ... forward pass via stacks g_profiler.EndTimer("StackForward"); }
Mithilfe von Profiling können wir Engpässe erkennen und unsere Optimierungsmaßnahmen dort ansetzen, wo sie wirklich etwas bewirken.
Ein Handelsroboter mit einem neuronalen Netzwerk ist nicht einfach nur Code, den man ausführen und dann vergessen kann. Es handelt sich um ein komplexes System, das eine ständige Überwachung, Diagnose und Anpassung erfordert. Ohne das richtige Überwachungssystem kann selbst die ausgefeilteste Architektur unbemerkt an Leistung einbüßen und schließlich Verluste verursachen.
Echtzeitüberwachung der PrognosequalitätDie erste Verteidigungslinie ist die kontinuierliche Überwachung der Prognosegenauigkeit in Echtzeit:
struct PredictionMonitor { double accuracy_buffer[]; double confidence_buffer[]; double actual_outcomes[]; int buffer_size, current_index; datetime last_evaluation; void Init(int size = 1000) { buffer_size = size; current_index = 0; ArrayResize(accuracy_buffer, buffer_size); ArrayResize(confidence_buffer, buffer_size); ArrayResize(actual_outcomes, buffer_size); ArrayInitialize(accuracy_buffer, 0.5); last_evaluation = TimeCurrent(); } void RecordPrediction(double prediction, double confidence) { confidence_buffer[current_index] = confidence; // Save the forecast for future evaluation // actual_outcomes will be filled later when the result is known } void RecordOutcome(double actual_movement) { if(current_index >= buffer_size) return; actual_outcomes[current_index] = actual_movement; // Calculate the forecast accuracy double predicted = confidence_buffer[current_index]; double accuracy = 1.0 - MathAbs(predicted - actual_movement); accuracy_buffer[current_index] = accuracy; current_index = (current_index + 1) % buffer_size; // Periodically display statistics if(TimeCurrent() - last_evaluation > 3600) { // Every hour PrintAccuracyReport(); last_evaluation = TimeCurrent(); } } void PrintAccuracyReport() { double total_accuracy = 0.0, total_confidence = 0.0; int valid_samples = 0; for(int i = 0; i < buffer_size; i++) { if(accuracy_buffer[i] > 0) { total_accuracy += accuracy_buffer[i]; total_confidence += confidence_buffer[i]; valid_samples++; } } if(valid_samples > 10) { double avg_accuracy = total_accuracy / valid_samples; double avg_confidence = total_confidence / valid_samples; Print("=== PREDICTION QUALITY REPORT ==="); Print("Average accuracy: ", DoubleToString(avg_accuracy * 100, 2), "%"); Print("Average confidence: ", DoubleToString(avg_confidence * 100, 2), "%"); Print("Valid samples: ", valid_samples); // Degradation warning if(avg_accuracy < 0.5) { Print("⚠️ WARNING: Model accuracy below random baseline!"); } if(avg_accuracy < avg_confidence - 0.1) { Print("⚠️ WARNING: Model overconfident - accuracy vs confidence gap!"); } } } double GetRecentAccuracy(int lookback = 100) { double sum = 0.0; int count = 0; for(int i = 0; i < MathMin(lookback, buffer_size); i++) { int idx = (current_index - i - 1 + buffer_size) % buffer_size; if(accuracy_buffer[idx] > 0) { sum += accuracy_buffer[idx]; count++; } } return (count > 0) ? sum / count : 0.5; } }; PredictionMonitor g_monitor;Erkennung von Konzeptdrift
Die Finanzmärkte entwickeln sich ständig weiter. Muster, die vor einem Monat noch funktioniert haben, sind möglicherweise nicht mehr relevant. Das System sollte solche Änderungen automatisch erkennen:
struct ConceptDriftDetector { double recent_performance[]; double historical_baseline; int window_size; bool drift_detected; datetime last_drift_check; void Init(int window = 200) { window_size = window; ArrayResize(recent_performance, window_size); historical_baseline = 0.55; // Base model accuracy drift_detected = false; last_drift_check = TimeCurrent(); } void AddPerformancePoint(double accuracy) { // Move the window for(int i = 0; i < window_size - 1; i++) { recent_performance[i] = recent_performance[i + 1]; } recent_performance[window_size - 1] = accuracy; // Check drift every 4 hours if(TimeCurrent() - last_drift_check > 4 * 3600) { CheckForDrift(); last_drift_check = TimeCurrent(); } } void CheckForDrift() { // Calculate the average performance in the window double window_mean = 0.0; int valid_count = 0; for(int i = 0; i < window_size; i++) { if(recent_performance[i] > 0) { window_mean += recent_performance[i]; valid_count++; } } if(valid_count < 50) return; // Not enough data window_mean /= valid_count; // Statistical test for significant deviation double variance = 0.0; for(int i = 0; i < window_size; i++) { if(recent_performance[i] > 0) { double diff = recent_performance[i] - window_mean; variance += diff * diff; } } variance /= (valid_count - 1); double std_error = MathSqrt(variance / valid_count); // Z test to determine the significance of the deviation double z_score = (window_mean - historical_baseline) / std_error; bool significant_drift = MathAbs(z_score) > 2.58; // 99% confidence level if(significant_drift && !drift_detected) { drift_detected = true; Print("🚨 CONCEPT DRIFT DETECTED!"); Print("Historical baseline: ", DoubleToString(historical_baseline, 3)); Print("Recent performance: ", DoubleToString(window_mean, 3)); Print("Z-score: ", DoubleToString(z_score, 2)); Print("Recommendation: Schedule model retraining"); // Automatically start retraining TriggerEmergencyRetraining(); } else if(!significant_drift && drift_detected) { drift_detected = false; Print("✅ Concept drift resolved - model performance stabilized"); } } void UpdateBaseline(double new_baseline) { historical_baseline = new_baseline; Print("📊 Performance baseline updated to ", DoubleToString(new_baseline, 3)); } }; ConceptDriftDetector g_drift_detector;System für Warnungen und automatische Reaktionen
Kritische Situationen erfordern eine sofortige Reaktion, selbst wenn der Trader schläft oder nicht erreichbar ist:
struct AlertSystem { enum ALERT_LEVEL { INFO = 0, WARNING = 1, CRITICAL = 2, EMERGENCY = 3 }; struct Alert { ALERT_LEVEL level; string message; datetime timestamp; bool acknowledged; }; Alert active_alerts[]; int max_alerts; datetime last_notification; void Init() { max_alerts = 100; ArrayResize(active_alerts, max_alerts); last_notification = 0; } void RaiseAlert(ALERT_LEVEL level, string message) { // Look for a free slot for an alert int slot = -1; for(int i = 0; i < max_alerts; i++) { if(active_alerts[i].timestamp == 0) { slot = i; break; } } if(slot == -1) { // Replace the oldest alert datetime oldest = TimeCurrent(); for(int i = 0; i < max_alerts; i++) { if(active_alerts[i].timestamp < oldest) { oldest = active_alerts[i].timestamp; slot = i; } } } // Create an alert active_alerts[slot].level = level; active_alerts[slot].message = message; active_alerts[slot].timestamp = TimeCurrent(); active_alerts[slot].acknowledged = false; // Display in the log with the corresponding prefixes string prefix = GetAlertPrefix(level); Print(prefix, " ", message); // Critical alerts require immediate action if(level >= CRITICAL) { HandleCriticalAlert(message); } // Limit the frequency of notifications if(TimeCurrent() - last_notification > 300) { // No more than once every 5 minutes SendNotification(level, message); last_notification = TimeCurrent(); } } string GetAlertPrefix(ALERT_LEVEL level) { switch(level) { case INFO: return "ℹ️ INFO:"; case WARNING: return "⚠️ WARNING:"; case CRITICAL: return "🚨 CRITICAL:"; case EMERGENCY: return "🆘 EMERGENCY:"; default: return "❓ UNKNOWN:"; } } void HandleCriticalAlert(string message) { // Automatic actions for critical alerts if(StringFind(message, "accuracy") >= 0) { // Accuracy issues - reducing position size ReducePositionSizes(0.5); } else if(StringFind(message, "memory") >= 0) { // Memory issues - forced cleanup g_memory_manager.ResetTempPool(); } else if(StringFind(message, "drift") >= 0) { // Conceptual drift - stop trading until retraining DisableTrading("Concept drift detected"); } } void SendNotification(ALERT_LEVEL level, string message) { // In a real system this could be: // - Send email via web requests // - Push notifications via Telegram Bot API // - SMS via external services string notification = StringFormat("[%s] %s: %s", TimeToString(TimeCurrent()), EnumToString(level), message); // For demonstration purposes, we simply output it to the terminal Print("📱 NOTIFICATION SENT: ", notification); } }; AlertSystem g_alerts;
Nach der Entwicklung des N-BEATS-Systems war es an der Zeit, dessen Wirksamkeit unter realen Handelsbedingungen zu testen. MetaTrader 5 bietet professionelle Testtools, die wir nutzen.
Testergebnisse des N-BEATS-Roboters
Leider konnten wir im Gegensatz zu früheren funktionierenden Modellen dieser Reihe – Mamba und PatchTST – trotz der vielversprechenden Architektur im Testzeitraum von Januar 2025 bis August 2025 keinen Gewinn erzielen:

Das Durcharbeiten von Dutzenden Artikeln über den Algorithmus und die Erstellung einer zweiten Version des EA haben die Situation nicht wirklich verbessert:

Trotz der technischen Komplexität und Eleganz der Umsetzung zeigten Tests mit historischen Daten für den Zeitraum Januar bis August 2025, dass das System nicht in der Lage ist, stabile Gewinne zu erzielen. Im Gegensatz zu den früheren erfolgreichen Mamba- und PatchTST-Architekturen ließ sich N-BEATS unter realen Handelsbedingungen nicht effektiv einsetzen.
Fazit
Die durchgeführte Studie hat gezeigt, dass eine direkte Anpassung der N-BEATS-Architektur an die Aufgabe der Prognose von Finanzzeitreihen nicht zu den erwarteten Ergebnissen führt. Die Hauptgründe waren der hohe Rauschpegel der Forex-Daten, die mangelnde Berücksichtigung der Marktmikrostruktur sowie das Missverhältnis zwischen dem Rechenaufwand und den erzielten Verbesserungen beim Handel.
Dennoch hat das Projekt einen erheblichen praktischen Nutzen. Es wurde eine Infrastruktur für Experimente mit neuronalen Netzen in MQL5 geschaffen, die Fehlerrückpropagation wurde von Grund auf neu implementiert und es wurden auf Unsicherheit basierende Risikomanagement-Tools entwickelt. Darüber hinaus wurden Überwachungs- und Diagnosesysteme implementiert, darunter die Erkennung von Konzeptdrift und die automatische Reaktion auf Modellverschlechterung, was für zahlreiche Handelslösungen, die auf maschinellem Lernen basieren, von Interesse ist.
Der vorgestellte Code kann als Grundlage für die weitere Forschung und Entwicklung spezialisierter Algorithmen dienen, die die Eigenschaften der Finanzmärkte genauer widerspiegeln. Die Ergebnisse unterstreichen die Notwendigkeit, Architekturen und Methoden des maschinellen Lernens an die Besonderheiten der Marktdynamik anzupassen, und bestätigen, dass der Erfolg in diesem Bereich eine Kombination aus technischen Lösungen und einem tiefgreifenden Verständnis wirtschaftlicher Prozesse erfordert.
| Dateiname | Dateiverwendung |
|---|---|
| NBeats_TimeSeriesNet.mqh | Die erste Version des Modells. Im Ordner „/Include“ ablegen. |
| NBeats_TimeSeriesNetV2.mqh | Die zweite Version des Modells. Im Ordner „/Include“ ablegen. |
| NBeats_EA.mq5 | Die erste Version des EA. Im Ordner „/Experts“ ablegen. |
| NBeats_EAV2.mq5 | Die zweite Version des EA. Im Ordner „/Experts“ ablegen. |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/19317
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.