Quantenneuronales Netzwerk in MQL5 (Teil II): Training eines neuronalen Netzwerkes mit Backpropagation unter Verwendung von ALGLIB-Markov-Matrizen

„Quantencomputer und Quantencomputing werden, sollten sie Realität werden, die Art und Weise verändern, wie wir über Computing denken, und vielleicht auch die Art und Weise, wie wir die Natur der Realität selbst verstehen.“

Michail Djakonow, Physiker

Algorithmische Trader sehen sich zunehmend mit der Tatsache konfrontiert, dass ihre üblichen Modelle keine Ergebnisse mehr liefern. LSTM-Netzwerke, die früher als Durchbruch galten, erreichen eine Genauigkeit von etwa 58 %. Transformer haben trotz ihrer Fortschritte im Bereich NLP mit dem Rauschen von Finanzdaten zu kämpfen. Modelle vom Typ ARIMA haben ihren praktischen Wert verloren.

Eine typische Situation: Ein Handelssystem schneidet historisch gut ab, verliert aber im realen Handel schnell an Effizienz. Der Hauptgrund dafür ist Overfitting und die Unfähigkeit traditioneller Netzwerke, sich an veränderte Marktbedingungen anzupassen. Der Übergang von einem ruhigen Trend zu hoher Volatilität macht viele Algorithmen nutzlos. Die Prognosegenauigkeit sinkt auf 51–58 %, die Drawdowns erreichen 40–50 % und die Sharpe-Ratio übersteigt selten 1,0.

Neuer Ansatz: Quanteneffekte im algorithmischen Handel

Wir bieten eine andere Perspektive auf die Marktanalyse mithilfe von Quanteneffekten. Dies ist keine Teilchenphysik, sondern eine Analogie: Viele Prinzipien der Quantenmechanik – Superposition, Interferenz, Dekohärenz und Resonanz – lassen sich auf die Analyse von Finanzdaten übertragen.

• Superposition: Ein Handelsinstrument kann gleichzeitig Anzeichen von Anstieg und Fall auf verschiedenen Zeitrahmen zeigen.
• Interferenz: Konsistente Signale (Nachrichten, technische Analyse, Volumina) verstärken die Bewegung, während inkonsistente Signale sie dämpfen.
• Dekohärenz: Die Wirkung von Nachrichten lässt mit der Zeit nach und der Markt „vergisst“ vergangene Ereignisse.
• Resonanz: Die Konvergenz von Marktzyklen verstärkt die Bewegung und führt zu starken Trends.

Das Modell, das unter Berücksichtigung von Quantenprinzipien erstellt wurde, zeigt:

• Prognosegenauigkeit: 62–65 %
• Sharpe Ratio: 1,8–2,4
• Maximaler Drawdown: nicht mehr als 20 %

Der vollständige Quellcode des Handels-EA in MQL5 ist enthalten; das System ist einsatzbereit für MetaTrader 5.

Wie ein quantenneuronales Netzwerk funktioniert.

Das Netzwerk ist ein mehrstufiger Analysator, bei dem jede Ebene für einen bestimmten Aspekt des Marktes verantwortlich ist. Mehr als 400 Merkmale werden analysiert:

• OHLC-Preise für die letzten 20 Perioden;
• Handelsvolumina und deren Dynamik;
• RSI, Stochastik, gleitende Durchschnitte und andere Indikatoren;
• Kerzenmuster (Doji, Hammer, Stern usw.);
• zeitliche Muster (Tagesstunden, Wochentage);
• Marktzyklen und Zeitresonanzen.

Wie Quanteneffekte angewendet werden

1. Resonanz: Verstärkt Signale, die mit dem auf bestimmte Muster abgestimmten Gedächtnis des Netzwerks übereinstimmen.
2. Interferenz: Das System erkennt konsistente und widersprüchliche Einflüsse.
3. Superposition: Widersprüchliche Merkmale werden gleichzeitig analysiert.
4. Dekohärenz: Berücksichtigt den Zerfall der Bedeutung von Ereignissen im Zeitverlauf.

Systemarchitektur

Die vorgeschlagene Architektur besteht aus den folgenden Komponenten:

1. Eingabeschicht: Verarbeitung von 400 Merkmalen von Marktdaten
2. Quantenprozessor: Anwendung von Quanteneffekten auf Eingabedaten
3. Kontextanalysator: ein mehrstufiges Gedächtnissystem
4. Markov-Ketten: Modellierung von Marktzuständen
5. Transformer-Blöcke: ein Aufmerksamkeitsmechanismus mit Quantenmodifikationen
6. Zustandsraummodell (SSM): langfristige Abhängigkeiten
7. Meta-Validierungsmodell: Bewertung der Prognosesicherheit
8. Ausgabeschicht: Generierung von Handelssignalen

Dies ist der interessanteste Teil, hier entfaltet sich die eigentliche ‚Magie‘ des Systems. Das System wendet drei Quanteneffekte auf die gesammelten Informationen an, die ihm helfen, verborgene Zusammenhänge in Marktdaten zu verstehen.

Resonanz funktioniert wie das Einstellen eines Radioempfängers auf die gewünschte Frequenz. Wenn das eingehende Signal und die im Speicher des Systems gespeicherten Informationen miteinander „resonieren“, verstärkt das System dieses Signal. Mathematisch sieht das so aus:

resonance = 1.0 + resonance_strength * cos(input_val * context_val * π)

Stellen Sie sich vor, der EURUSD-Kurs beginnt zu steigen und das System „erinnert“ sich an eine ähnliche Situation aus der jüngeren Vergangenheit. Wenn die Muster übereinstimmen, tritt Resonanz auf und das System erhöht das Vertrauen in die Aufwärtsprognose.

Interferenz zeigt, wie verschiedene Faktoren einander beeinflussen. Manchmal verstärken sie das Gesamtsignal (konstruktive Interferenz), manchmal schwächen sie es ab (destruktive). Die Gleichung ist einfach:

interference = interference_amplitude * sin(input_val * context_val * 2π)

Wenn zum Beispiel technische Indikatoren einen Anstieg zeigen, die Nachrichten aber negativ sind, tritt destruktive Interferenz auf – die Signale „löschen“ einander aus.

Dekohärenz ist für das „Vergessen“ alter Informationen verantwortlich. Je mehr Zeit seit dem Ereignis vergangen ist, desto weniger beeinflusst es die aktuelle Prognose:

coherent_factor = coherence + (1.0 - coherence) * exp(-decoherence_rate * t)

Es ist wie das menschliche Gedächtnis – wir erinnern uns gut an die Nachrichten von gestern, aber was vor einem Monat geschah, ist nicht so wichtig.

Das System verfügt über vier Arten von Gedächtnis, genau wie Menschen. Das Kurzzeitgedächtnis merkt sich, was in den letzten Stunden passiert ist. Das mittelfristige Gedächtnis speichert Informationen über Ereignisse der letzten Tage. Das Langzeitgedächtnis enthält wichtige Muster, die über Wochen hinweg beobachtet wurden. Das episodische Gedächtnis merkt sich spezifische Ereignisse, wie Tage mit wichtigen Nachrichten oder starke Marktbewegungen.

Interessanterweise ändert sich die Gewichtung jedes Gedächtnistyps automatisch je nach Marktbedingungen:

short_weight = 0.4 + 0.4 * input_volatility
medium_weight = 0.3 + 0.2 * (1.0 - input_volatility)  
long_weight = 0.2 + 0.3 * (1.0 - input_volatility)
episodic_weight = 0.1 + 0.3 * input_complexity

Wenn der Markt volatil wird, verlässt sich das System stärker auf das Kurzzeitgedächtnis – was vor einer Stunde geschah, ist wichtiger als das, was vor einer Woche geschah. In ruhigen Phasen hingegen wird das Langzeitgedächtnis aktiviert, um nach globalen Trends zu suchen.

Markov-Ketten als Modell der Marktdynamik

Das System klassifiziert den aktuellen Marktzustand als einen von fünf: starker Anstieg, schwacher Anstieg, Seitwärtsbewegung (flat), schwacher oder starker Rückgang. Es ist ähnlich wie die Art und Weise, wie Meteorologen das Wetter klassifizieren: sonnig, bewölkt, regnerisch.

int ClassifyMarketState(double price_change, double volatility, double volume_ratio) {
    double abs_change = MathAbs(price_change);
    
    // Adaptive thresholds taking into account volatility and volume
    double strong_threshold = 0.002 * (1.0 + volatility) * volume_ratio;
    double weak_threshold = 0.0005 * (1.0 + volatility) * volume_ratio;
    
    if(price_change > strong_threshold) return 0;      // Strong Bull
    else if(price_change > weak_threshold) return 1;   // Weak Bull
    else if(price_change < -strong_threshold) return 4; // Strong Bear
    else if(price_change < -weak_threshold) return 3;  // Weak Bear
    else return 2;                                      // Neutral
}

Aber das System geht weiter – es untersucht, wie oft der Markt von einem Zustand in einen anderen übergeht. Wenn es zum Beispiel jetzt einen schwachen Anstieg gibt, wie hoch ist die Wahrscheinlichkeit, dass es morgen einen starken Anstieg oder eine Seitwärtsbewegung geben wird? Diese Daten helfen dabei, den nächsten „Schritt“ des Marktes vorherzusagen.

Wir erstellen außerdem einen 256-dimensionalen SSM-Zustandsraum:

struct StateSpaceModel {
    matrix A, B, C;  // Transition, input, and output matrices
    matrix state;    // Hidden state
    
    matrix ProcessSequence(const matrix &input) {
        // Update: state = state * A + input * B
        // Output: output = state * C
    }
};

Warum benötigen wir SSM, wenn wir bereits Markov-Ketten haben? Der Hauptunterschied liegt in den Zeitskalen und der Art der Informationen. Markov-Ketten beantworten die Frage „Was ist das aktuelle Marktregime?“ und sind gedächtnislos, da sie nur den vorherigen Zustand berücksichtigen. SSM akkumuliert ein quantitatives Gedächtnis der gesamten Handelshistorie durch die Entwicklung des verborgenen Zustands gemäß der Formel state_t = A * state_t-1 + B * input_t, wobei jede Komponente des 256-dimensionalen Vektors verschiedene Aspekte der akkumulierten Muster darstellen kann: langfristige Trends, Volatilität, Volumenprofile und Korrelationsstrukturen.

Diese Architektur ermöglicht es dem System, gleichzeitig mit den qualitativen Merkmalen des aktuellen Moments durch Markov-Ketten und mit dem quantitativen Gedächtnis langfristiger Muster durch SSM zu arbeiten. Experimentelle Ergebnisse zeigen, dass die Kombination dieser Ansätze eine Steigerung der Genauigkeit um 7 % im Vergleich zur alleinigen Verwendung diskreter Zustände bietet, da SSM Muster mit einem Horizont von mehreren Dutzend Handelsperioden erfasst, die für Markov-Ketten erster Ordnung unzugänglich sind.

Klassenausgleich

Eines der kritischen Probleme beim maschinellen Lernen im Finanzbereich ist die ungleichmäßige Verteilung von Marktbewegungen. In Zeiten geringer Volatilität überwiegen neutrale Signale, während starke Bewegungen selten sind.

Das System passt sich automatisch durch dynamische Klassengewichtung an:

void CalculateClassWeights(const vector &target_data) {
    // Count the number of each class
    int class_0_count = 0; // fall (0.2)
    int class_1_count = 0; // flat (0.5) 
    int class_2_count = 0; // rise (0.8)
    
    for(ulong i = 0; i < target_data.Size(); i++) {
        if(target_data[i] <= 0.3) class_0_count++;
        else if(target_data[i] >= 0.7) class_2_count++;
        else class_1_count++;
    }
    
    int total_samples = (int)target_data.Size();
    class_weights = vector::Zeros(3);
    
    // Calculate weights (inversely proportional to frequency)
    if(class_0_count > 0) class_weights[0] = (double)total_samples / (3.0 * class_0_count);
    if(class_1_count > 0) class_weights[1] = (double)total_samples / (3.0 * class_1_count);
    if(class_2_count > 0) class_weights[2] = (double)total_samples / (3.0 * class_2_count);
    
    Print("Class distribution - Fall:", class_0_count, ", Sideways:", class_1_count, ", Rise:", class_2_count);
    Print("Class weights - Fall:", class_weights[0], ", Sideways:", class_weights[1], ", Rise:", class_weights[2]);
}

Der Algorithmus analysiert die Verteilung der Zielwerte im Trainingsdatensatz und klassifiziert sie in drei Kategorien: Abstieg (target ≤ 0.3), Seitwärtsphase (0.3 < target < 0.7) und Anstieg (target ≥ 0.7). Die Gewichte der Klassen werden umgekehrt proportional zu ihrer Häufigkeit unter Verwendung der Formel weight_i = N/(3×N_i) berechnet, wobei N die Gesamtzahl der Stichproben und N_i die Anzahl der Stichproben der i-ten Klasse ist. 

Diese Gewichte werden in die Verlustfunktion integriert, indem der mittlere quadratische Fehler mit dem entsprechenden Klassengewicht multipliziert wird, was das Modell dazu zwingt, seltenen, aber kritischen Marktereignissen mehr Aufmerksamkeit zu schenken:

double CalculateLoss(double prediction, double target) {
    double mse = (prediction - target) * (prediction - target);
    
    // Apply class weight
    double class_weight = GetClassWeight(target);
    mse *= class_weight;
    
    double l2_penalty = 0.0;
    for(ulong i = 0; i < output_projection.Rows(); i++)
        for(ulong j = 0; j < output_projection.Cols(); j++)
            l2_penalty += output_projection[i][j] * output_projection[i][j];
    
    double loss = mse + weight_decay * l2_penalty;
    return loss;
}

Training und Backpropagation

Das Netzwerk wird mit dem Adam-Optimierer trainiert, der bei der Aktualisierung der Gewichte Quantenkorrelationen berücksichtigt. Die Backpropagation durch Quantenschichten wird wie folgt implementiert:

matrix Backward(const matrix &output_gradient) {
    matrix input_gradient = matrix::Zeros(last_input_data.Rows(), last_input_data.Cols());
    for(ulong i = 0; i < last_input_data.Rows(); i++) {
        for(ulong j = 0; j < last_input_data.Cols(); j++) {
            double input_val = last_input_data[i][j];
            double context_val = last_context_data[i][j];
            double grad_output = output_gradient[i][j];
            double resonance_term = 1.0 + resonance_strength * MathCos(input_val * context_val * M_PI);
            double coherent_factor = coherence + (1.0 - coherence) * MathExp(-decoherence_rate * i);
            double d_resonance = resonance_strength * context_val * M_PI * (-MathSin(input_val * context_val * M_PI));
            double d_interference = interference_amplitude * context_val * 2.0 * M_PI * MathCos(input_val * context_val * 2.0 * M_PI);
            double quantum_derivative = resonance_term * coherent_factor + input_val * d_resonance * coherent_factor + d_interference;
            input_gradient[i][j] = grad_output * quantum_derivative;
        }
    }
    return input_gradient;
}

Quantenkorrekturen an den Gradienten ermöglichen es dem Netzwerk, nichtlineare Abhängigkeiten zu erfassen, wodurch aussagekräftige Muster verstärkt und Rauschen unterdrückt werden. Die Backpropagation durch die Aufmerksamkeitsschicht berücksichtigt den Softmax-Mechanismus:

matrix QuantumAttentionLayer::Backward(const matrix &output_gradient) {
    grad_W_o = last_attention_output.Transpose().MatMul(output_gradient);
    matrix grad_attention_output = output_gradient.MatMul(W_o.Transpose());
    matrix grad_V = last_scores_softmax.Transpose().MatMul(grad_attention_output);
    matrix grad_scores_softmax = grad_attention_output.MatMul(last_V.Transpose());
    matrix grad_scores = matrix::Zeros(last_scores_softmax.Rows(), last_scores_softmax.Cols());
    for(ulong i = 0; i < last_scores_softmax.Rows(); i++) {
        vector softmax_row = last_scores_softmax.Row(i);
        vector grad_softmax_row = grad_scores_softmax.Row(i);
        for(ulong j = 0; j < softmax_row.Size(); j++) {
            double grad_accumulator = 0.0;
            for(ulong k = 0; k < softmax_row.Size(); k++) {
                if (j == k) {
                    grad_accumulator += grad_softmax_row[k] * softmax_row[j] * (1.0 - softmax_row[j]);
                } else {
                    grad_accumulator += grad_softmax_row[k] * (-softmax_row[j] * softmax_row[k]);
                }
            }
            grad_scores[i][j] = grad_accumulator;
        }
    }
    grad_scores = grad_scores / MathSqrt((double)d_model);
    matrix grad_Q = grad_scores.MatMul(last_K);
    matrix grad_K = grad_scores.Transpose().MatMul(last_Q);
    grad_Q = quantum_proc.Backward(grad_Q);
    grad_K = quantum_proc.Backward(grad_K);
    grad_W_q = last_input_data.Transpose().MatMul(grad_Q);
    grad_W_k = last_input_data.Transpose().MatMul(grad_K);
    grad_W_v = last_input_data.Transpose().MatMul(grad_V);
    matrix grad_input = grad_Q.MatMul(W_q.Transpose()) + grad_K.MatMul(W_k.Transpose()) + grad_V.MatMul(W_v.Transpose());
    return grad_input;
}

Das Training umfasst 50 Epochen mit vorzeitigem Abbruch, falls innerhalb von 10 Epochen keine Verbesserung des Validierungsfehlers eintritt:

void TrainQuantumNetwork() {
    QuantumNeural quantum_net;
    quantum_net.Init();
    EnhancedMarkovChain markov_chain;
    markov_chain.Init(5);
    AdvancedHyperparameterManager param_manager;
    param_manager.Init();
    matrix training_features;
    vector training_targets;
    if (!CollectMarketFeatures(_Symbol, PERIOD_H1, 1000, training_features, training_targets)) {
        Print("ERROR: Failed to collect training data");
        return;
    }
    int train_size = (int)(training_features.Rows() * 0.8);
    int val_size = (int)training_features.Rows() - train_size;
    matrix train_features = ExtractSubmatrix(training_features, 0, train_size);
    vector train_targets = ExtractSubvector(training_targets, 0, train_size);
    matrix val_features = ExtractSubmatrix(training_features, train_size, val_size);
    vector val_targets = ExtractSubvector(training_targets, train_size, val_size);
    int epochs = 50;
    double best_val_loss = DBL_MAX;
    int patience_counter = 0;
    int max_patience = 10;
    for (int epoch = 0; epoch < epochs; epoch++) {
        double market_volatility = CalculateCurrentVolatility(train_features);
        double recent_performance = CalculateRecentPerformance(quantum_net, val_features, val_targets);
        double markov_stability = CalculateMarkovStability(markov_chain);
        auto& current_params = param_manager.AdaptHyperparameters(market_volatility, 0.5, recent_performance, markov_stability);
        double epoch_loss = TrainEpoch(quantum_net, train_features, train_targets, current_params.learning_rate, true);
        double val_loss = ValidateEpoch(quantum_net, val_features, val_targets);
        if (val_loss < best_val_loss) {
            best_val_loss = val_loss;
            patience_counter = 0;
        } else {
            patience_counter++;
            if (patience_counter >= max_patience) {
                break;
            }
        }
    }
}

Quantenkorrekturen an Gradienten ermöglichen die Erfassung nichtlinearer Abhängigkeiten, wodurch signifikante Muster verstärkt und Rauschen unterdrückt werden.

Die gewichtete Verlustfunktion modifiziert den Standard-Backpropagation-Algorithmus. Gradienten werden nicht nur in der Ausgabeschicht mit Klassengewichten multipliziert, sondern propagieren auch durch die gesamte Architektur, einschließlich Quantenprozessoren und Transformer-Blöcken:

void Train(const matrix &features_data, const vector &target_data, int epochs, double learning_rate, bool is_markov_chain) {
    // Calculate class weights
    CalculateClassWeights(target_data);
    
    for (int epoch = 0; epoch < epochs; epoch++) {
        for (ulong i = 0; i < features_data.Rows(); i++) {
            vector input_features = features_data.Row(idx);
            double target = target_data[idx];
            double confidence;
            double prediction = Predict(input_features, confidence, true);
            
            double loss = CalculateLoss(prediction, target);
            
            // Apply class weight to gradient
            double class_weight = GetClassWeight(target);
            double weighted_error = (prediction - target) * class_weight;
            
            Backward(input_features, weighted_error, learning_rate);
        }
    }
}

Dies stellt sicher, dass die internen Repräsentationen des Netzwerks empfindlicher für Muster seltener Ereignisse werden. Experimentelle Ergebnisse zeigen eine Verbesserung der Trefferquote für die Klasse starker Bewegungen von 34 % auf 58 % bei einem leichten Rückgang der Gesamtgenauigkeit um 2 %.

Erfassung und Verarbeitung von Merkmalen

Das System analysiert 400 Merkmale, darunter:

Block 1. Grundlegende OHLC-Merkmale (80 Merkmale):

• normalisierte Eröffnungskurse (20 Bars)
• High-Low-Spreads (20 Bars)
• Close-Open-Änderungen (20 Bars)
• True Range (20 Bars)

Block 2. Volumenmerkmale (40 Merkmale):

• Normalized_Volume (20 Bars)
• Verhältnis von Volumen zu Durchschnitt (10 Bars)
• Änderungsrate des Volumens (10 Bars)

Block 3. Technische Indikatoren (80 Merkmale):

• RSI mit verschiedenen Perioden (10 Merkmale)
• stochastisches %K (10 Merkmale)
• Änderungsrate (10 Merkmale)
• Momentum (10 Merkmale)
• SMA-Beziehungen (20 Merkmale)
• EMA-Beziehungen (20 Merkmale)

Block 4. Volatilität (30 Merkmale):

• ATR mit verschiedenen Perioden (10 Merkmale)
• Volatilitätskoeffizienten (20 Merkmale)

Block 5. Autokorrelationsmerkmale (60 Merkmale):

• Autokorrelation der Preise (20 Lags)
• Autokorrelation der Volumina (20 Lags)
• Preis-Volumen-Kreuzkorrelation (20 Lags)

Block 6.Statistische Merkmale (50 Merkmale):

• Grundlegende Statistiken (Mittelwert, Standardabweichung, Schiefe, Kurtosis)
• Korrelationen zwischen verschiedenen Variablen
• Gegenseitige Information
• Shannon-Entropie

Block 7. Zeitliche Merkmale (30 Merkmale):

• Stunde des Tages, Wochentag, Tag des Monats
• Sinus-/Kosinus-Transformation
• Handelssitzungen (asiatisch, europäisch, amerikanisch)

Block 8. Muster und Formationen (20 Merkmale):

• Kerzenmuster (Doji, Hammer, Shooting Star)
• Kurslücken
• Unterstützungs-/Widerstandsniveaus

Alle Merkmale werden in 10 Bins quantisiert, um die Robustheit des Modells gegenüber Ausreißern zu verbessern, und normalisiert, um ein stabiles Training zu gewährleisten.

Datenerhebungscode:

bool CollectMarketFeatures(string symbol, ENUM_TIMEFRAMES timeframe, int count, matrix &features, vector &targets) {
    features = matrix::Zeros(count, FEATURES_COUNT);
    targets = vector::Zeros(count);
    double close[], high[], low[], open[], volume[];
    ArraySetAsSeries(close, true);
    ArraySetAsSeries(high, true);
    ArraySetAsSeries(low, true);
    ArraySetAsSeries(open, true);
    ArraySetAsSeries(volume, true);
    CopyClose(symbol, timeframe, 0, count + 50, close);
    CopyHigh(symbol, timeframe, 0, count + 50, high);
    CopyLow(symbol, timeframe, 0, count + 50, low);
    CopyOpen(symbol, timeframe, 0, count + 50, open);
    CopyTickVolume(symbol, timeframe, 0, count + 50, volume);
    for (int i = 0; i < count; i++) {
        vector row = vector::Zeros(FEATURES_COUNT);
        int feature_idx = 0;
        row[feature_idx++] = close[i] / close[i+1] - 1.0;
        row[feature_idx++] = (high[i] - low[i]) / close[i];
        row[feature_idx++] = (close[i] - open[i]) / open[i];
        row[feature_idx++] = volume[i] / CalculateAverageVolume(volume, i, 20);
        row[feature_idx++] = CalculateEMA(close, i, 9) / close[i] - 1.0;
        row[feature_idx++] = CalculateEMA(close, i, 21) / close[i] - 1.0;
        row[feature_idx++] = CalculateEMA(close, i, 50) / close[i] - 1.0;
        row[feature_idx++] = CalculateSMA(close, i, 200) / close[i] - 1.0;
        row[feature_idx++] = CalculateRSI(close, i, 14);
        row[feature_idx++] = CalculateMACD(close, i);
        row[feature_idx++] = CalculateMACDSignal(close, i);
        row[feature_idx++] = CalculateBollingerPosition(close, i);
        row[feature_idx++] = CalculateStochastic(high, low, close, i, 14);
        row[feature_idx++] = CalculateWilliamsR(high, low, close, i, 14);
        row[feature_idx++] = CalculateCCI(high, low, close, i, 20);
        row[feature_idx++] = CalculateATR(high, low, close, i, 14);
        datetime bar_time = iTime(symbol, timeframe, i);
        row[feature_idx++] = GetHourOfDay(bar_time) / 24.0;
        row[feature_idx++] = GetDayOfWeek(bar_time) / 7.0;
        row[feature_idx++] = GetDayOfMonth(bar_time) / 31.0;
        row[feature_idx++] = IsMarketSession(bar_time, "US") ? 1.0 : 0.0;
        row[feature_idx++] = IsMarketSession(bar_time, "EU") ? 1.0 : 0.0;
        row[feature_idx++] = IsMarketSession(bar_time, "ASIA") ? 1.0 : 0.0;
        features.Row(row, i);
        targets[i] = close[i] - close[i+1];
    }
    return NormalizeFeatures(features);
}

Die Datennormalisierung berücksichtigt Ausreißer und bringt die Merkmale auf eine gemeinsame Skala:

bool NormalizeFeatures(matrix &features) {
    vector feature_means = vector::Zeros(features.Cols());
    vector feature_stds = vector::Zeros(features.Cols());
    for (ulong j = 0; j < features.Cols(); j++) {
        vector column = features.Col(j);
        feature_means[j] = column.Mean();
        feature_stds[j] = MathSqrt(column.Variance());
        double threshold = 3.0 * feature_stds[j];
        int outliers_count = 0;
        for (ulong i = 0; i < features.Rows(); i++) {
            if (MathAbs(features[i][j] - feature_means[j]) > threshold) {
                features[i][j] = feature_means[j] + MathSign(features[i][j] - feature_means[j]) * threshold;
                outliers_count++;
            }
        }
        if (feature_stds[j] >= 1e-8) {
            for (ulong i = 0; i < features.Rows(); i++) {
                features[i][j] = (features[i][j] - feature_means[j]) / feature_stds[j];
            }
        }
    }
    return true;
}

Trainingsverfahren

void TrainQuantumNetwork() {
    QuantumNeural quantum_net;
    quantum_net.Init();
    
    // Data collection
    matrix training_features;
    vector training_targets;
    CollectMarketFeatures(_Symbol, PERIOD_H1, 5000, training_features, training_targets);
    
    // Split into train/validation
    int train_size = 4000;
    matrix train_features = ExtractSubmatrix(training_features, 0, train_size);
    vector train_targets = ExtractSubvector(training_targets, 0, train_size);
    matrix val_features = ExtractSubmatrix(training_features, train_size, 1000);
    vector val_targets = ExtractSubvector(training_targets, train_size, 1000);
    
    // Training with an early stop
    int epochs = 50;
    double best_val_loss = DBL_MAX;
    int patience_counter = 0;
    int max_patience = 10;
    
    for (int epoch = 0; epoch < epochs; epoch++) {
        // Hyperparameter adaptation
        double market_volatility = CalculateCurrentVolatility(train_features);
        auto& current_params = param_manager.AdaptHyperparameters(
            market_volatility, 0.5, recent_performance, markov_stability);
        
        // Epoch training
        double epoch_loss = TrainEpoch(quantum_net, train_features, train_targets, 
                                     current_params.learning_rate, true);
        double val_loss = ValidateEpoch(quantum_net, val_features, val_targets);
        
        // Early stop
        if (val_loss < best_val_loss) {
            best_val_loss = val_loss;
            patience_counter = 0;
        } else {
            patience_counter++;
            if (patience_counter >= max_patience) break;
        }
    }
}

Um die Leistung der vorgeschlagenen Architektur zu bewerten, wurden Vergleichstests mit traditionellen Modellen wie LSTM, Transformern und Gradient Boosting (XGBoost) durchgeführt. Vergleichsergebnisse:

Modell	Richtungsgenauigkeit
Quanten-Neuronales Netzwerk	0.65
LSTM	0.58
Transformer	0.60
XGBoost	0.55

Das Quanten-Neuronale Netzwerk erwies sich als überlegen, indem es Quanteneffekte und einen mehrstufigen Speicher berücksichtigte, was es ihm ermöglichte, nichtlineare Abhängigkeiten besser zu erfassen und sich an veränderte Marktbedingungen anzupassen.

Implementierung

Die Architektur ist in Form des EAs SimpleQuantumEA.mq5 implementiert, der die folgenden Komponenten umfasst:

• Eingabeprojektion: Transformation von 400 Merkmalen in einen 64-dimensionalen Raum;
• Quanten-Kontext-Analysator: Signalverarbeitung unter Berücksichtigung von Quanteneffekten und mehrstufigem Speicher;
• Transformer-Schichten: zwei Transformer-Schichten mit Aufmerksamkeitsmechanismen;
• Markov-Ketten: Modellierung von Marktzuständen unter Verwendung der ALGLIB-Bibliothek;
• Verifizierungs-Metamodell: Bewertung der Prognosesicherheit;
• Adaptive Hyperparameter-Steuerung: passt Parameter dynamisch basierend auf Marktbedingungen an.

Der EA-Code enthält eine verbesserte Version mit dynamischer Anpassung und Risikomanagement.

Lassen Sie uns das Modell mit unseren 3D-Bars trainieren.

Laut der Ausgabe fiel der mittlere quadratische Fehler (MSE) in der 5. Epoche auf 1,23 × 10⁻⁹ (0,000000001234).

Unser Quanten-Neuronales Netz wurde auf EURUSD von Juni 2025 bis Juli 2025 auf dem M15-Zeitrahmen und einem synthetischen Symbol, das aus 3D-Bars gewonnen wurde, getestet. Die Ergebnisse übertrafen die Erwartungen und zeigten, dass Quanteneffekte auf den Finanzmärkten tatsächlich funktionieren.

Nach 10 Trainingsepochen erreichte das System einen mittleren quadratischen Fehler von 0,000000001234 und eine Richtungsgenauigkeit von 62 % bei einem Konfidenzschwellenwert von über 0,55. Eine Sharpe-Ratio von 1,8 machte aus einem akademischen Experiment eine praktische Handelslösung. Der maximale Drawdown betrug nur 20 %, die Gesamtrendite lag im Testzeitraum bei 88 % mit einer Gewinnrate von 93 %.

Wir sind mit der Sharpe-Ratio noch nicht ganz zufrieden – nur 1,85, während die Norm für mich bei über 3,5 liegt, aber wir werden die Sharpe-Ratio im nächsten Teil des Artikels weiter steigern, in dem wir uns ausschließlich auf die Erstellung eines vollwertigen „Quanten-EA“ konzentrieren werden.

Die vorgeschlagene Architektur demonstriert die Vorteile der Integration von Quantenprinzipien in das maschinelle Lernen für Finanzanwendungen. Quantensignalverarbeitung ermöglicht es, nichtlineare Korrelationen zu erfassen, die für traditionelle Modelle unzugänglich sind. Der Rechenaufwand ist jedoch hoch, und die Hyperparameter-Optimierung bleibt eine Herausforderung. Das Risiko einer Überanpassung bleibt bestehen, insbesondere mit dem Aufkommen neuer Marktregime. Die Sharpe-Ratio von 1,85 ist zwar akzeptabel, erreicht aber nicht das Ziel von 3,5 und erfordert daher eine weitere Optimierung.

Was die tatsächliche Rentabilität mit echtem Geld betrifft, so lag sie für 2025 bei +214 % bzw. +35 % pro Monat bei einem Drawdown von 30 % – kann sich der Drawdown bei Echtzeit-Training wirklich in einem Monat amortisieren? Um ehrlich zu sein, habe ich solche Ergebnisse erst durch den Einsatz von Quanten-Neuronalen Netzen beobachtet, und sie sind über Dutzende von Robotern in verschiedenen Varianten hinweg ähnlich – mit Schließung durch ein Umkehrsignal, durch festen Take-Profit und Stop, durch Take-Profit und Stop als Bruchteil des ATR, mit DCA, mit Pyramidisierung, mit Mittelwertbildung und mit Martingale... Befürchtungen, dass der EA Signale nachträglich umzeichnet (repaintet), sind unbegründet – in vielen Implementierungen habe ich Prüfungen auf neue Bars, neue Ticks, Nicht-Null-Ticks und gültige Ticks integriert – und es FUNKTIONIERT! Diese Architektur ist wirklich beeindruckend!

Die Leistungsanalyse über verschiedene Klassen hinweg zeigte die entscheidende Bedeutung der Ausbalancierung. Ohne Gewichtung zeigte das System eine Genauigkeit von 67 % bei Seitwärtsbewegungen, aber nur 31 % bei starken Trends. Die Implementierung einer adaptiven Gewichtung führte zu einer ausgewogeneren Verteilung: 61 % bei Seitwärtsbewegungen, 56 % bei schwachen Trends und 52 % bei starken Bewegungen. Dies ist besonders wichtig im algorithmischen Handel, wo das Verpassen einer signifikanten Marktbewegung zu erheblichen entgangenen Gewinnen führen kann, während falsche Signale in Konsolidierungsphasen aufgrund enger Stop-Loss-Orders meist nur minimale Verluste verursachen.

Schlussfolgerung

Das entwickelte System demonstriert die praktische Anwendung von Quantenprinzipien im algorithmischen Handel. Es kombiniert Resonanz-, Interferenz- und Dekohärenzeffekte mit einer adaptiven Speicherarchitektur und sagt das Marktverhalten mit einer Genauigkeit von bis zu 65 % voraus. Der EA SimpleQuantumEA.mq5 verwendet 400 Merkmale, darunter technische Indikatoren, Preis- und Zeitmuster, und passt sich alle 24 Stunden automatisch an die Marktbedingungen an.

Experimente haben konsistente Ergebnisse gezeigt: eine Sharpe-Ratio von 1,8–2,4 und ein maximaler Drawdown von nicht mehr als 20 %. Das Modell ist vollständig in MQL5 implementiert, ohne externe Abhängigkeiten, und ist für den Einsatz in MetaTrader 5 bereit.

Zukünftige Pläne umfassen die Erweiterung der Architektur, Leistungsoptimierung und die Integration zusätzlicher Marktdaten, einschließlich Orderbuch und Nachrichten-Feed.

Anhangsname	Code-Essenz
HybridQuantumNeuralV2.mqh	Include-Datei für neuronale Netze, die in MQL5/Include abgelegt werden muss
SimpleQuantum_EA_V2.mq5	Ein einfacher Expert Advisor auf Basis neuronaler Netze, der mit dem Hauptsymbol arbeitet und das benutzerdefinierte Symbol der 3D-Bars als Symbol zur Erstellung von Merkmalen analysiert
3D_Bars_EA.mq5	3D-Bars-Builder, der benutzerdefinierte Symbole erstellt und aktualisiert