Quantenneuronales Netz in MQL5 (Teil I): Erstellen der Include-Datei

Stellen Sie sich einen Trader vor, der niemals schläft, niemals in Panik gerät und in der Lage ist, Tausende Marktmuster gleichzeitig zu analysieren. Stellen Sie sich zudem vor, dass dieser Trader das Gedächtnis eines Elefanten, die Intuition eines Genies und die Fähigkeit hat, sofort zu lernen. Klingt nach Science-Fiction? Willkommen in der Welt des quantenneuronalen Netzwerks in MQL5.

Was wir heute erschaffen, geht weit über einfaches maschinelles Lernen hinaus. Es ist eine Symbiose aus Quantenmechanik und künstlicher Intelligenz, die in Form von Code umgesetzt ist, der direkt in Ihrem MetaTrader 5 ausgeführt werden kann. Unsere Architektur sagt nicht nur Preisbewegungen voraus – sie versteht den Markt auf einem Niveau, das dem menschlichen Bewusstsein verschlossen bleibt. 

Eine Revolution im Verständnis des Gedächtnisses

Das menschliche Gehirn arbeitet gleichzeitig mit mehreren Arten von Gedächtnis. Wenn ein erfahrener Trader auf einen Chart schaut, erinnert er sich sofort an ähnliche Situationen aus der Vergangenheit, analysiert den aktuellen Kontext und bildet ein intuitives Verständnis dafür, was als Nächstes passieren könnte. Dieses Prinzip bildet die Grundlage unseres ContextAnalyzer, einer revolutionären Komponente, die menschliche Intuition in digitaler Form nachbildet.

Unser Gedächtnissystem arbeitet auf fünf Ebenen, von denen jede ihre eigene Spezialisierung hat. Das Kurzzeitgedächtnis erfasst sofortige Marktveränderungen – jeden Tick, jede Preisbewegung. Das mittelfristige Gedächtnis sammelt Informationen über Trends auf Stunden- und Tagesbasis. Das Langzeitgedächtnis speichert grundlegende Muster, die über Monate und Jahre hinweg entstehen.

Aber die wahre Magie beginnt mit dem episodischen Gedächtnis. Es wird nur aktiviert, wenn etwas wirklich Wichtiges passiert – ein starker Anstieg der Volatilität, unerwartete Nachrichten, ein Trendwechsel. Diese Momente prägen sich besonders stark ein und bilden einzigartige „Erinnerungen“, die das System nutzt, um ähnliche Situationen in der Zukunft zu erkennen.

Die Architektur kombiniert Gedächtnistypen über verschiedene Zeithorizonte hinweg (von kurzfristig bis langfristig), um sich an die Marktdynamik anzupassen. Der Aufmerksamkeitsmechanismus und die Transformer-Architektur sorgen für die Auswahl relevanter Informationen und deren Abstraktion. Das Zustandsraummodell ist für zeitliche Abhängigkeiten verantwortlich, und der ContextAnalyzer integriert die Gedächtniskomponenten unter Berücksichtigung der Volatilität. Ein Quantenprozessor verstärkt Signale und unterdrückt Rauschen, und das MetaVerificationModel überprüft die Zuverlässigkeit von Vorhersagen. Die gesamte Architektur fungiert als selbstregulierendes System mit integrierter kritischer Bewertung.

Quantenmechanik in Aktion

Klassische neuronale Netze verarbeiten Informationen linear – Daten gelangen durch eine Abfolge von Transformationen vom Eingang zum Ausgang. Unser System arbeitet grundlegend anders. Wir wenden die Prinzipien der Quantenmechanik an: Superposition, Interferenz und Resonanz.

Wenn verschiedene Gedächtnistypen miteinander interagieren, erzeugen sie Interferenzmuster – genau wie Lichtwellen sich gegenseitig verstärken oder auslöschen können. Diese Interferenzen führen zu emergenten Eigenschaften, die nicht durch einfaches Addieren der Komponenten erzielt werden können.

double resonance_factor = 1.0 + 0.5 * MathCos(input_val * linear_context * M_PI);
double interference = 0.3 * MathSin(short_context * medium_context * 2.0 * M_PI) +
                     0.2 * MathCos(long_context * episodic_context * M_PI) +
                     0.1 * MathSin(pattern_context * input_val * 3.0 * M_PI);

Diese Formeln sind nicht nur mathematische Berechnungen. Sie beschreiben, wie verschiedene „Realitätsebenen“ im Markt miteinander resonieren und komplexe Harmonien erzeugen, die unser System erkennen und für Prognosen nutzen kann.

Transformer als architektonische Revolution

Im Zentrum der modernen KI steht der Aufmerksamkeitsmechanismus – die Fähigkeit des Modells, sich auf wirklich wichtige Informationen zu konzentrieren und Rauschen zu ignorieren. Unser UShapeTransformer hebt diese Idee auf die nächste Stufe.

Stellen Sie sich einen Orchesterdirigenten vor, der jedes Instrument gleichzeitig hören und verstehen kann, wie sie miteinander interagieren. Der Aufmerksamkeitsmechanismus arbeitet auf ähnliche Weise: Er berechnet die Wichtigkeit jedes Elements der Eingabesequenz im Verhältnis zu allen anderen Elementen.

void Forward(Matrix &input_matrix, Matrix &output_matrix)
{
    // Create matrices of queries, keys, and values
    MatrixMultiply(input_matrix, W_q, Q);
    MatrixMultiply(input_matrix, W_k, K);
    MatrixMultiply(input_matrix, W_v, V);
    
    // Calculate attention weights
    for(int i = 0; i < seq_len; i++)
    {
        for(int j = 0; j < seq_len; j++)
        {
            double dot_product = 0.0;
            for(int k = 0; k < d_model; k++)
                dot_product += Q.Get(i, k) * K.Get(j, k);
            attention_weights.Set(i, j, dot_product / MathSqrt(d_model));
        }
    }
}

Die U-förmige Architektur fügt eine weitere Ebene der Komplexität hinzu. Die Informationen durchlaufen zunächst einen Encoder, der die Eingabedaten komprimiert und abstrahiert und dabei die wichtigsten Merkmale hervorhebt. Der Decoder rekonstruiert diese Informationen dann, jedoch angereichert mit Kontext und einem Verständnis für tiefe Zusammenhänge.

Alchemie des Codes: Ein digitales Gehirn erschaffen

Das Fundament: die Struktur Matrix
Jede komplexe Struktur beginnt mit einem starken Fundament. In unserem Fall ist dies eine Matrixstruktur – nicht nur ein Container für Zahlen, sondern ein intelligentes System zur Verwaltung mehrdimensionaler Daten.

struct Matrix
{
    double data[];
    int rows, cols;

    void Init(int r, int c)
    {
        rows = r;
        cols = c;
        ArrayResize(data, r * c);
        ArrayInitialize(data, 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 Set(int r, int c, double val)
    {
        if(r < 0 || r >= rows || c < 0 || c >= cols) return;
        data[r * cols + c] = val;
    }

    void Random(double range = 0.5)
    {
        for(int i = 0; i < ArraySize(data); i++)
            data[i] = (MathRand() / 32767.0 - 0.5) * 2.0 * range;
    }
}

Es scheint sich um eine einfache Struktur zu handeln. Doch sie basiert auf der Philosophie von Sicherheit und Zuverlässigkeit. Jeder Datenzugriff wird überprüft, jede Operation wird kontrolliert. Dies ist besonders kritisch für Finanzsysteme, bei denen ein Fehler echtes Geld kosten kann.

StateSpaceModel: Sich an die Vergangenheit erinnern, in die Zukunft blicken
Märkte haben ein Gedächtnis. Was gestern geschah, beeinflusst die Ereignisse von heute. Was heute geschieht, bestimmt die Möglichkeiten von morgen. StateSpaceModel verkörpert diese grundlegende Wahrheit in mathematischer Form.

struct StateSpaceModel
{
    Matrix A, B, C;  // State, input, and output matrices
    Matrix state;    // Current state of the system
    int input_size, state_size;

    void ProcessSequence(Matrix &_input, Matrix &output)
    {
        output.Init(_input.rows, _input.cols);
        
        for(int t = 0; t < _input.rows; t++)
        {
            // Extract the current input vector
            Matrix input_row;
            input_row.Init(1, _input.cols);
            for(int j = 0; j < _input.cols; j++)
                input_row.Set(0, j, _input.Get(t, j));

            // Update internal state
            Matrix new_state;
            new_state.Init(1, state_size);
            
            // state = A * state + B * input
            for(int i = 0; i < state_size; i++)
            {
                double sum = 0.0;
                for(int k = 0; k < state_size; k++)
                    sum += A.Get(i, k) * state.Get(0, k);
                
                for(int k = 0; k < _input.cols; k++)
                    sum += B.Get(k, i) * input_row.Get(0, k);
                    
                new_state.Set(0, i, sum);
            }
            
            state = new_state;

            // Calculate output: output = C * state
            for(int j = 0; j < _input.cols; j++)
            {
                double sum = 0.0;
                for(int k = 0; k < state_size; k++)
                    sum += C.Get(k, j) * state.Get(0, k);
                output.Set(t, j, sum);
            }
        }
    }
}

Die Schönheit dieses Modells liegt in seiner Einfachheit und Leistungsfähigkeit. Drei Matrizen bestimmen, wie sich das System im Laufe der Zeit entwickelt. Matrix A beschreibt die interne Dynamik – wie vergangene Zustände zukünftige beeinflussen. Matrix B definiert, wie externe Einflüsse (neue Daten) den Zustand des Systems verändern. Matrix C zeigt, wie sich der interne Zustand in externen Beobachtungen manifestiert.

ContextAnalyzer: Digitale Intuition
Die komplexeste und innovativste Komponente unseres Systems ist der ContextAnalyzer. Hier geschieht die eigentliche Magie: die Umwandlung von Rohdaten in Verständnis.

void ProcessWithContext(Matrix &_input, Matrix &output)
{
    output.Init(_input.rows, _input.cols);

    static Matrix short_term_memory, medium_term_memory, long_term_memory;
    static Matrix episodic_memory, pattern_memory;
    static bool memory_initialized = false;
    static int sequence_counter = 0;
    static double importance_buffer[100];
    static int buffer_index = 0;

    if(!memory_initialized)
    {
        short_term_memory.Init(5, context_size);
        medium_term_memory.Init(50, context_size);
        long_term_memory.Init(10, context_size);
        episodic_memory.Init(20, context_size);
        pattern_memory.Init(15, context_size);
        
        // Initialize all memory types
        ArrayInitialize(short_term_memory.data, 0.0);
        ArrayInitialize(medium_term_memory.data, 0.0);
        ArrayInitialize(long_term_memory.data, 0.0);
        ArrayInitialize(episodic_memory.data, 0.0);
        ArrayInitialize(pattern_memory.data, 0.0);
        ArrayInitialize(importance_buffer, 0.0);
        
        memory_initialized = true;
    }

    sequence_counter++;

    // Analyze input data characteristics
    double input_volatility = 0.0;
    double input_magnitude = 0.0;
    double input_complexity = 0.0;

    // Calculate volatility, magnitude, and complexity
    for(int i = 0; i < _input.rows; i++)
    {
        double row_sum = 0.0, row_variance = 0.0;
        for(int j = 0; j < _input.cols; j++)
        {
            double val = _input.Get(i, j);
            row_sum += val;
            input_magnitude += MathAbs(val);
        }

        double row_mean = row_sum / _input.cols;
        for(int j = 0; j < _input.cols; j++)
        {
            double val = _input.Get(i, j);
            row_variance += (val - row_mean) * (val - row_mean);
        }

        input_volatility += MathSqrt(row_variance / _input.cols);

        // Evaluate complexity through change analysis
        for(int j = 1; j < _input.cols; j++)
        {
            if(MathAbs(_input.Get(i, j) - _input.Get(i, j-1)) > 0.1)
                input_complexity += 1.0;
        }
    }

    input_volatility /= _input.rows;
    input_magnitude /= (_input.rows * _input.cols);
    input_complexity /= (_input.rows * (_input.cols - 1));

Das System analysiert ständig die Art der eingehenden Daten. Hohe Volatilität führt zu einer stärkeren Gewichtung des Kurzzeitgedächtnisses. Komplexe Muster aktivieren das episodische und das Mustergedächtnis. Dies sind keine starren Regeln, sondern dynamische Gewichtungen, die sich an die aktuelle Marktsituation anpassen.

Nun geschieht das Interessanteste – Quanteninteraktionen zwischen verschiedenen Arten des Gedächtnisses:

// Dynamic calculation of weights for different memory types
double short_weight = 0.4 + 0.4 * input_volatility;
double medium_weight = 0.3 + 0.2 * (1.0 - input_volatility);
double long_weight = 0.2 + 0.3 * (1.0 - input_volatility);
double episodic_weight = 0.1 + 0.3 * input_complexity;
double pattern_weight = 0.15 + 0.25 * input_complexity;

// Normalize weights
double total_weight = short_weight + medium_weight + long_weight + episodic_weight + pattern_weight;
short_weight /= total_weight;
medium_weight /= total_weight;
long_weight /= total_weight;
episodic_weight /= total_weight;
pattern_weight /= total_weight;

for(int i = 0; i < _input.rows; i++)
{
    for(int j = 0; j < _input.cols; j++)
    {
        double input_val = _input.Get(i, j);
        double context_idx = j % context_size;

        // Extract context from different memory types
        double short_context = short_term_memory.Get(sequence_counter % 5, context_idx);
        double medium_context = medium_term_memory.Get(sequence_counter % 50, context_idx);
        double long_context = long_term_memory.Get(sequence_counter % 10, context_idx);
        double episodic_context = episodic_memory.Get(sequence_counter % 20, context_idx);
        double pattern_context = pattern_memory.Get(sequence_counter % 15, context_idx);

        // Linear combination of contexts
        double linear_context = short_weight * short_context +
                               medium_weight * medium_context +
                               long_weight * long_context +
                               episodic_weight * episodic_context +
                               pattern_weight * pattern_context;

        // Quantum effects: resonance and interference
        double resonance_factor = 1.0 + 0.5 * MathCos(input_val * linear_context * M_PI);
        double interference = 0.3 * MathSin(short_context * medium_context * 2.0 * M_PI) +
                             0.2 * MathCos(long_context * episodic_context * M_PI) +
                             0.1 * MathSin(pattern_context * input_val * 3.0 * M_PI);

        double nonlinear_factor = 1.0 + input_volatility * MathSin(linear_context * 2.0 * M_PI);

        // Integrate all effects
        double integrated_context = linear_context * resonance_factor * nonlinear_factor + interference;

        // Determine the strength of contextual influence
        double context_strength = 0.4 + 0.3 * input_complexity;
        double final_output = (1.0 - context_strength) * input_val + context_strength * integrated_context;

        output.Set(i, j, final_output);
    }
}

Dies sind keine bloßen mathematischen Operationen. Jede Formel hat eine tiefe Bedeutung. Resonanz tritt auf, wenn sich aktuelle Daten mit dem angesammelten Kontext „synchronisieren“. Interferenz erzeugt komplexe Interaktionsmuster zwischen verschiedenen Zeitskalen. Nichtlineare Faktoren erhöhen die Anpassungsfähigkeit und ermöglichen es dem System, auf sich ändernde Marktbedingungen zu reagieren.

Trainings- und Anpassungssystem
Wahre Intelligenz zeigt sich nicht durch die Fähigkeit, sich zu erinnern, sondern durch die Fähigkeit, zu lernen und sich anzupassen. Unser System analysiert ständig die Bedeutung eingehender Informationen und aktualisiert sein Gedächtnis entsprechend:

// Evaluate the importance of current data
double importance = input_volatility + input_complexity + MathAbs(input_val);
importance_buffer[buffer_index] = importance;
buffer_index = (buffer_index + 1) % 100;

double avg_importance = 0.0;
for(int k = 0; k < 100; k++) avg_importance += importance_buffer[k];
avg_importance /= 100.0;

// Adaptive learning rate
double learning_rate = (importance > avg_importance) ? 0.3 : 0.05;

// Update different memory types at different speeds
double new_short = short_context * (1.0 - 0.4) + final_output * 0.4;
short_term_memory.Set(sequence_counter % 5, context_idx, new_short);

double new_medium = medium_context * (1.0 - 0.1) + final_output * 0.1;
medium_term_memory.Set(sequence_counter % 50, context_idx, new_medium);

double new_long = long_context * (1.0 - 0.02) + final_output * 0.02;
long_term_memory.Set(sequence_counter % 10, context_idx, new_long);

// Episodic memory is activated only for important events
if(importance > avg_importance * 1.5)
{
    double new_episodic = episodic_context * 0.7 + final_output * 0.3;
    episodic_memory.Set(sequence_counter % 20, context_idx, new_episodic);
}

// Pattern memory is updated when correlations are detected
double pattern_correlation = input_val * linear_context;
if(MathAbs(pattern_correlation) > 0.1)
{
    double pattern_update = pattern_correlation * learning_rate;
    double new_pattern = pattern_context * 0.9 + pattern_update * 0.1;
    pattern_memory.Set(sequence_counter % 15, context_idx, new_pattern);
}

Das System funktioniert wie ein lebender Organismus. Es sammelt nicht nur Informationen – es versteht, was wichtig ist und was ignoriert werden kann. Wichtige Ereignisse werden lange gespeichert, Routinedaten werden schnell vergessen. Muster, die sich wiederholen, werden stärker. Zufälliges Rauschen wird herausgefiltert.

MetaVerificationModel: Die Kunst des Zweifels
Eines der Hauptprobleme beim maschinellen Lernen ist das Übervertrauen des Modells. Das System kann Vorhersagen mit hoher „Sicherheit“ treffen, selbst wenn die Eingabedaten inkonsistent oder unzureichend sind. MetaVerificationModel löst dieses Problem durch eine zusätzliche Ebene kritischer Bewertung.

struct MetaVerificationModel
{
    Matrix meta_weights;
    Matrix meta_output_weights;

    void Init()
    {
        int meta_input_size = FEATURES_COUNT + 1 + 3; // features + forecast + metrics
        meta_weights.Init(meta_input_size, 16);
        meta_weights.Random(0.3);
        meta_output_weights.Init(16, 1);
        meta_output_weights.Random(0.5);
    }

    double Forward(double &original_features[], double first_model_prediction, double &error_metrics[])
    {
        // Forming the meta input
        double meta_input[];
        int total_input_size = ArraySize(original_features) + 1 + ArraySize(error_metrics);
        ArrayResize(meta_input, total_input_size);

        // Copy the original features
        for(int i = 0; i < ArraySize(original_features); i++)
            meta_input[i] = original_features[i];

        // Add the main model forecast
        meta_input[ArraySize(original_features)] = first_model_prediction;

        // Add error metrics
        for(int i = 0; i < ArraySize(error_metrics); i++)
            meta_input[ArraySize(original_features) + 1 + i] = error_metrics[i];

        // Forward propagation through the hidden layer
        double hidden[];
        ArrayResize(hidden, 16);

        for(int i = 0; i < 16; i++)
        {
            double sum = 0.0;
            for(int j = 0; j < ArraySize(meta_input) && j < meta_weights.cols; j++)
                sum += meta_input[j] * meta_weights.Get(j, i);
            hidden[i] = Tanh(sum);
        }

        // Calculate the final output
        double output = 0.0;
        for(int i = 0; i < 16; i++)
            output += hidden[i] * meta_output_weights.Get(i, 0);

        return Sigmoid(output); // Return confidence from 0 to 1
    }
}

Das Metamodell analysiert nicht nur die Ausgangsdaten und die Prognose des Hauptmodells, sondern auch die Fehlerhistorie, aktuelle Qualitätsmetriken und Marktverhaltensmuster. Es lernt, Situationen zu erkennen, in denen das zugrunde liegende Modell fehleranfällig ist, und reduziert dementsprechend das Vertrauen in seine Vorhersagen.

Speicherausgleich
Einer der Schlüsselaspekte für einen effizienten Systembetrieb ist die korrekte Konfiguration der verschiedenen Gedächtnistypen. Jeder Markt hat seine eigenen Charakteristika, und es gibt keine universellen Einstellungen.

Für volatile Märkte wie Kryptowährungen sollte der Einfluss des Kurzzeit- und episodischen Gedächtnisses erhöht werden. Das System sollte schnell auf plötzliche Veränderungen reagieren und sich an extreme Ereignisse erinnern. Für stabilere Instrumente, wie Staatsanleihen, sollte dem Langzeit- und Mustergedächtnis mehr Gewicht beigemessen werden.

// Adaptive adjustment of memory weights depending on the instrument
void AdaptMemoryWeights(string symbol)
{
    if(StringFind(symbol, "BTC") >= 0 || StringFind(symbol, "ETH") >= 0)
    {
        // Settings for cryptocurrencies
        short_term_base_weight = 0.5;
        episodic_base_weight = 0.25;
        long_term_base_weight = 0.1;
    }
    else if(StringFind(symbol, "USD") >= 0)
    {
        // Forex settings
        short_term_base_weight = 0.35;
        medium_term_base_weight = 0.35;
        long_term_base_weight = 0.2;
    }
    // And so on for different types of assets
}

Selbstdiagnosesystem
Ein intelligentes System sollte seine eigenen Grenzen verstehen. Wir implementieren Selbstdiagnosefunktionen, die verschiedene Aspekte des Modellbetriebs überwachen:

void RunDiagnostics()
{
    static int diagnostic_counter = 0;
    diagnostic_counter++;
    
    if(diagnostic_counter % 1000 == 0) // every thousand ticks
    {
        // Entropy analysis in different types of memory
        double short_entropy = context_analyzer.CalculateMemoryEntropy(short_term_memory);
        double long_entropy = context_analyzer.CalculateMemoryEntropy(long_term_memory);
        double pattern_entropy = context_analyzer.CalculateMemoryEntropy(pattern_memory);
        
        // If short-term memory is too chaotic and long-term memory is too stable
        if(short_entropy > 2.5 && long_entropy < 0.5)
        {
            Print("DIAGNOSIS: Memory imbalance detected. Increasing connectivity.");
            // Increase interaction between memory types
            interference_strength += 0.1;
        }
        
        // If the system becomes too conservative
        if(pattern_entropy < 0.3)
        {
            Print("DIAGNOSIS: The system is too conservative. Adding exploratory noise.");
            exploration_noise += 0.05;
        }
        
        // Analyze forecast quality
        double recent_accuracy = prediction_history.GetRecentAccuracy(50);
        if(recent_accuracy < 0.4)
        {
            Print("DIAGNOSIS: Low accuracy of forecasts. Activating retraining mode.");
            learning_rate_multiplier = 1.5;
            confidence_threshold += 0.1; // Raise the bar for confidence
        }
    }
}

Quanteneffekte in Aktion

Der faszinierendste Teil unseres Systems sind die quanteninspirierten Interaktionen zwischen den verschiedenen Komponenten. Schauen wir uns an, wie sie in der Praxis funktionieren.

Resonanz tritt auf, wenn eingehende Daten auf dieselbe „Frequenz“ wie die im Gedächtnis gespeicherten Inhalte abgestimmt sind. Dies erzeugt einen Effekt der Signalverstärkung – wichtige Muster werden ausgeprägter und Rauschen wird unterdrückt.

Interferenz fungiert als ein System zur gegenseitigen Überprüfung. Wenn verschiedene Gedächtnistypen miteinander abgeglichen werden, verstärkt dies das Gesamtsignal. Wenn sie sich widersprechen, erzeugt dies eine „destruktive Interferenz“, die dazu führt, dass das System bei seinen Vorhersagen vorsichtiger ist.

// Example of analysis of quantum effects
void AnalyzeQuantumEffects(double input_val, double linear_context)
{
    double resonance = MathCos(input_val * linear_context * M_PI);
    
    if(MathAbs(resonance) > 0.8)
    {
        if(resonance > 0)
            Print("QUANTUM EFFECT: Strong constructive resonance detected");
        else
            Print("QUANTUM EFFECT: Strong destructive resonance detected");
    }
    
    // Analyze interference patterns
    double interference_pattern = AnalyzeInterferencePattern();
    if(MathAbs(interference_pattern) > threshold)
    {
        Print("QUANTUM EFFECT: Complex interference pattern detected");
        // The market may be in a transitional state
    }
}

Philosophie der künstlichen Intelligenz im Handel

Die Schaffung unseres Quanten-Neuronalen Netzes wirft tiefgreifende Fragen über das Wesen der Intelligenz und die Vorhersehbarkeit der Finanzmärkte auf. Kann eine Maschine den Markt wirklich „verstehen“ oder erkennt sie lediglich komplexe Korrelationen in den Daten? Wir schlagen einen dritten Weg vor: eine Architektur, die über das bloße Erinnern an Muster oder das Finden von Korrelationen hinausgeht. Unser System erstellt eine mehrstufige Repräsentation der Marktrealität, wobei jede Ebene für einen einzigartigen Aspekt der Wahrnehmung und Analyse verantwortlich ist.

• Kurzzeitgedächtnis erfasst sofortige Veränderungen in der Stimmung der Marktteilnehmer – jeden Tick, jede Preisschwankung. Es ist wie ein empfindliches Radar, das kurzzeitige Impulse aufnimmt.

• Mittelfristiges Gedächtnis verfolgt Trends und Zyklen, die sich auf Stunden- und Tagesbasis bilden, und identifiziert Muster in der Entwicklung von Marktbewegungen.

• Langzeitgedächtnis speichert fundamentale wirtschaftliche Muster, die über Monate und Jahre hinweg entstehen, und verleiht dem System eine strategische Vision.

• Episodisches Gedächtnis erfasst einzigartige, kritische Ereignisse – starke Volatilitätsspitzen, unerwartete Nachrichten oder Trendwechsel. Diese „Erinnerungen“ ermöglichen es dem System, die Wiederholung ähnlicher Szenarien zu antizipieren.

• Mustergedächtnis fungiert wie eine digitale Intuition und extrahiert tiefe Strukturen, die sich über verschiedene Zeitskalen und Marktbedingungen hinweg wiederholen.

Quanteneffekte – Resonanz, Interferenz und Kohärenz – fügen eine neue Ebene der Komplexität hinzu. Sie ermöglichen es dem System, Unsicherheit nicht als Hindernis, sondern als Quelle wertvoller Informationen wahrzunehmen. Wie Quantenteilchen, die in einer Superposition von Zuständen existieren, ist unser Netzwerk in der Lage, gleichzeitig mehrere mögliche Marktszenarien zu berücksichtigen, aussagekräftige Signale zu verstärken und Rauschen zu unterdrücken. Dies macht Unsicherheit zu einem Lernwerkzeug und ermöglicht es dem System, sich an die chaotische Natur der Märkte anzupassen.

Die Vorteile eingebetteter MQL5-Matrizen: Vom Fahrrad zum Raumschiff

Anfangs verließ sich unser System auf unsere eigene Implementierung von Matrixoperationen, was dem Neuerfinden des Rades gleichkam. Die MQL5-Entwickler haben jedoch hervorragende Arbeit geleistet, indem sie integrierte Matrix- und Vektortypen sowie die <matrix.mqh>-Bibliothek bereitgestellt haben, die unser „Fahrrad“ in ein Hochleistungs-Raumschiff verwandelten. Die Verwendung nativer Matrixoperationen ermöglichte es uns, den Codeumfang radikal zu reduzieren sowie dessen Lesbarkeit und Leistung zu verbessern.

Vorteile integrierter MQL5-Matrizen:

• Hohe Leistung: Operationen wie die Matrixmultiplikation (MatMul, @-Operator) nutzen die Vektorbefehle des Prozessors und bieten Beschleunigungen, die um ein Vielfaches schneller sind als manuelle Schleifen.

• Zuverlässigkeit: Integrierte Typen eliminieren Indexierungsfehler und gewährleisten numerische Stabilität, was für Finanzberechnungen entscheidend ist, bei denen jede Ungenauigkeit zu Verlusten führen kann.

• Kürze und Klarheit: Der Code ist der mathematischen Notation näher gekommen, was seine Entwicklung und Wartung vereinfacht. Anstatt umständlicher Schleifen für die Matrixmultiplikation reicht es beispielsweise aus, Q = input @ W_q zu schreiben.

• Vorgefertigte Werkzeuge für maschinelles Lernen: RandUniform, Exp, Sigmoid, ReLU und andere Funktionen ermöglichen es uns, uns auf die übergeordnete Logik statt auf Berechnungen auf niedriger Ebene zu konzentrieren.

• Optimierte Speicherverwaltung: Integrierte Typen minimieren Speicherzuweisungen, was besonders bei der Verarbeitung großer Mengen von Marktdaten in Echtzeit wichtig ist.

Schauen wir uns an einem Beispiel an, wie sich der Code bei Verwendung integrierter Typen ändert:

Vorher

Nachher

void Forward(Matrix &input_matrix, Matrix &output_matrix)    {       int seq_len = input_matrix.rows;              Matrix Q, K, V;       Q.Init(seq_len, d_model);       K.Init(seq_len, d_model);       V.Init(seq_len, d_model);       // Simple matrix multiplication Q = input * W_q       for(int i = 0; i < seq_len; i++)       {          for(int j = 0; j < d_model; j++)          {             double q_sum = 0.0, k_sum = 0.0, v_sum = 0.0;             for(int k = 0; k < d_model; k++)             {                double input_val = input_matrix.Get(i, k);                q_sum += input_val * W_q.Get(k, j);                k_sum += input_val * W_k.Get(k, j);                v_sum += input_val * W_v.Get(k, j);             }             Q.Set(i, j, q_sum);             K.Set(i, j, k_sum);             V.Set(i, j, v_sum);          }       }       // Calculate attention weights       Matrix attention_weights;       attention_weights.Init(seq_len, seq_len);       for(int i = 0; i < seq_len; i++)       {          double max_score = -DBL_MAX;                   // Calculate scores          for(int j = 0; j < seq_len; j++)          {             double score = 0.0;             for(int k = 0; k < d_model; k++)                score += Q.Get(i, k) * K.Get(j, k);                          score /= MathSqrt(d_model);             attention_weights.Set(i, j, score);             if(score > max_score) max_score = score;          }          // Softmax          double sum_exp = 0.0;          for(int j = 0; j < seq_len; j++)          {             double exp_val = MathExp(attention_weights.Get(i, j) - max_score);             attention_weights.Set(i, j, exp_val);             sum_exp += exp_val;          }          if(sum_exp > 0)          {             for(int j = 0; j < seq_len; j++)                attention_weights.Set(i, j, attention_weights.Get(i, j) / sum_exp);          }       }       // Apply weights to values       output_matrix.Init(seq_len, d_model);       for(int i = 0; i < seq_len; i++)       {          for(int j = 0; j < d_model; j++)          {             double sum = 0.0;             for(int k = 0; k < seq_len; k++)                sum += attention_weights.Get(i, k) * V.Get(k, j);             output_matrix.Set(i, j, sum);          }       }    }

matrix Forward(const matrix &input_data)    {       // Calculate Q, K, V       matrix Q = input_data.MatMul(W_q);       matrix K = input_data.MatMul(W_k);       matrix V = input_data.MatMul(W_v);              // Apply quantum effects       Q = quantum_proc.ApplyQuantumEffects(Q, input_data);       K = quantum_proc.ApplyQuantumEffects(K, input_data);              // Calculate attention weights       matrix scores = Q.MatMul(K.Transpose()) / MathSqrt((double)d_model);              // Softmax across rows       for(ulong i = 0; i < scores.Rows(); i++)       {          vector row = scores.Row(i);                   // Find the maximum value for numerical stability          double max_val = row.Max();                   // Subtract the maximum and apply the exponential element-wise          for(ulong j = 0; j < row.Size(); j++)          {             row[j] = MathExp(row[j] - max_val);          }                   // Normalize (divide by the sum)          double sum = row.Sum();          row = row / sum;                   // Write back to the matrix          scores.Row(row, i);       }              // Apply to values and output projection       matrix attention_output = scores.MatMul(V);       return attention_output.MatMul(W_o);    }

Der vollständige optimierte Code befindet sich in der angehängten Datei QuantumNeuralMQL.mqh.

Die Kenntnis der Möglichkeiten von MQL5 erwies sich als der Schlüssel zur Erstellung komplexer neuronaler Netze. Anstatt Zeit mit dem Schreiben eigener Implementierungen grundlegender Operationen zu verbringen, können wir uns auf die Entwicklung innovativer Architekturen wie unseren ContextAnalyzer oder QuantumProcessor konzentrieren. Das Studium der MQL5-Dokumentation (wie z. B. Matrixoperationen) schafft die Grundlage für eine effiziente Implementierung mathematisch komplexer Algorithmen und macht den Prozess der Erstellung neuronaler Netze nicht nur produktiv, sondern auch spannend.

Abschließend verwenden wir ein kleines Skript, um sicherzustellen, dass der Code funktioniert.

//+------------------------------------------------------------------+
//| Usage example                                                    |
//+------------------------------------------------------------------+
// Using in EA:
SimpleQuantumNeural neural_net;

int OnInit()
{
   neural_net.Init();
   return INIT_SUCCEEDED;
}

void OnTick()
{
   double features[];
   if(MarketDataCollector::CollectSimpleFeatures(_Symbol, PERIOD_H1, 10, features))
   {
      double prediction[];
      neural_net.Forward(features, prediction);
      
      if(ArraySize(prediction) > 0)
      {
         double signal = prediction[0];
         Comment("Quantum signal: ", DoubleToString(signal, 4));
         
         if(signal > 0.6)
         {
            // Buy
         }
         else if(signal < 0.4)
         {
            // Sell
         }
      }
   }
   
   // Diagnostics
   static int counter = 0;
   counter++;
   if(counter % 100 == 0)
      neural_net.PrintDiagnostics();
}

Schlussfolgerung

Das resultierende System ist nicht nur ein Algorithmus, sondern eine selbstlernende Struktur, die in der Lage ist, sich anzupassen und ihr eigenes Verständnis des Marktes zu entwickeln.

Schlüsselkomponenten:

• Matrizen – die mathematische Grundlage
• StateSpaceModel – Dynamik im Zeitverlauf
• Transformer – Aufmerksamkeit und Verallgemeinerung
• ContextAnalyzer – mehrstufige Erkenntnisse
• MetaVerificationModel – Validierung von Schlussfolgerungen

Der Haupteffekt wird durch das Zusammenspiel dieser Module erzielt. Der zweite Teil des Artikels behandelt Beispiele für die Verwendung, Konfiguration und Optimierung des Systems in der Praxis. Der Übergang zu neuen Formen der KI im Handel hat gerade erst begonnen.