English Русский 中文 Español Português
preview
Handelsroboter auf Basis eines GPT-Modells für Finanzzeitreihen

Handelsroboter auf Basis eines GPT-Modells für Finanzzeitreihen

MetaTrader 5 — Handelssysteme |
30 2
Yevgeniy Koshtenko
Yevgeniy Koshtenko

Einleitung

TimeGPT ist ein Modell für maschinelles Lernen, das entwickelt wurde, um Kursbewegungen an den Finanzmärkten, beispielsweise bei Devisenpaaren oder Aktien, auf der MetaTrader-5-Plattform vorherzusagen. Es basiert auf der Transformer-Architektur, die ursprünglich für die Verarbeitung von Text – beispielsweise für Übersetzungen oder die Textgenerierung – entwickelt wurde, nun aber für die Analyse von Finanzdaten angepasst wurde. In diesem Artikel werde ich Schritt für Schritt ausführlich erläutern, wie TimeGPT entsteht, und dabei auf die Architektur, die Datenverarbeitung, das Training und die Prognosen eingehen. Alles wird in einfacher Sprache und anhand von Vergleichen erklärt, sodass auch jemand, der gerade erst mit dem Thema maschinelles Lernen beginnt, verstehen kann, wie ein solches Modell erstellt wird. Abschließend werde ich auch auf die Grenzen des Modells und seine Anforderungen an die Rechenleistung eingehen.

Was braucht es, um ein Modell wie TimeGPT zu entwickeln?

Bevor wir uns mit dem Code befassen, ist es wichtig, zu verstehen, womit TimeGPT arbeitet. Finanzmärkte liefern Daten in Form von Zeitreihen – einer Abfolge von Kursen, die in regelmäßigen Abständen, beispielsweise stündlich, erfasst werden. Die Marktpreise folgen keinen einfachen Regeln: Sie können aufgrund von Nachrichten in die Höhe schnellen, langsam fallen oder ohne ersichtlichen Grund schwanken. Die Aufgabe von TimeGPT besteht darin, Muster in diesen Daten zu erkennen und vorherzusagen, wie sich der Kurs in 24 Stunden verändern wird – ein Zeitraum, der im Kurschart 24 Balken entspricht.

Die Entwicklung eines Modells erfordert die Lösung mehrerer Probleme. Zunächst müssen wir festlegen, wie die Kursdaten gespeichert und verarbeitet werden sollen. Dann müssen wir diese Daten in ein Format umwandeln, das das Modell verstehen kann. Als Nächstes müssen wir die Modellarchitektur so gestalten, dass sie komplexe Zusammenhänge in den Daten erkennen kann. Das Modell wird anschließend anhand historischer Daten trainiert, um zu lernen, wie es genaue Vorhersagen treffen kann. Schließlich ist es angesichts der Einschränkungen der MetaTrader-5-Plattform wichtig, das Modell so zu optimieren, dass es schnell läuft und nicht zu viel Arbeitsspeicher beansprucht. Sehen wir uns nun jeden dieser Schritte anhand des Codes aus der Datei „TimeGPT_Fixed.mqh“ genauer an.



Modellentwicklung

Erstellen einer Struktur für die Arbeit mit Daten

Der erste Schritt bei der Entwicklung von TimeGPT bestand darin, eine Struktur für die Speicherung und Verarbeitung von Daten zu schaffen. Im maschinellen Lernen werden Daten häufig als Matrizen dargestellt – also als Tabellen mit Zahlen, die sich gut für mathematische Operationen eignen. Zu diesem Zweck wurde in TimeGPT die Struktur „TGMatrix“ erstellt, die es ermöglicht, Zahlen wie Kurse oder Modellparameter in geordneter Form zu speichern.

So sieht der Code für diese Struktur aus:

struct TGMatrix {
    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) const { 
        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 RandomInit(double scale = -1.0) {
        if(scale < 0) scale = MathSqrt(2.0 / (rows + cols));
        for(int i = 0; i < ArraySize(data); i++) {
            data[i] = (MathRand() / 32767.0 - 0.5) * 2.0 * scale;
        }
    }
    
    void Add(const TGMatrix &other) {
        if(rows != other.rows || cols != other.cols) return;
        for(int i = 0; i < ArraySize(data); i++) {
            data[i] += other.data[i];
        }
    }
    
    void Copy(const TGMatrix &other) {
        Init(other.rows, other.cols);
        for(int i = 0; i < ArraySize(other.data); i++) {
            data[i] = other.data[i];
        }
    }
    
    void Scale(double factor) {
        for(int i = 0; i < ArraySize(data); i++) {
            data[i] *= factor;
        }
    }
};

Stellen Sie sich TGMatrix wie eine Excel-Tabelle vor, in der Zahlen in Zeilen und Spalten gespeichert sind. Die Methode „Init“ erstellt eine Tabelle in der gewünschten Größe. Mit „Get“ und „Set“ können Sie Werte aus bestimmten Zellen auslesen bzw. in diese schreiben. „RandomInit“ füllt die Tabelle mit Zufallszahlen, die für die Initialisierung des Modells benötigt werden. Die Methoden „Add“, „Copy“ und „Scale“ führen grundlegende Operationen durch, wie beispielsweise das Addieren zweier Tabellen oder das Multiplizieren aller Zahlen mit einem bestimmten Wert. Diese Struktur bildete die Grundlage für die Arbeit mit Daten in TimeGPT, da alle Kurse, Modellparameter und Berechnungen auf Matrizen basieren. Wir haben uns für diesen Ansatz entschieden, weil er einfach ist und in MetaTrader 5 gut funktioniert, wo komplexe Bibliotheken wie Python nicht verwendet werden können.

Umwandlung der Preise in ein für das Modell verständliches Format

Damit das Modell die Preise analysieren kann, müssen diese in ein geeignetes Format umgewandelt werden. TimeGPT greift eine Idee aus der Textverarbeitung auf: Jede Kursänderung wird in ein „Token“ umgewandelt – eine Zahl, die die Kursbewegung darstellt, beispielsweise einen Anstieg um 0,5 % oder einen Rückgang um 0,3 %. Die Struktur „ImprovedTokenizer“ ist dafür zuständig.

Hier ist der Code dazu:

struct ImprovedTokenizer {
    double price_mean, price_std;
    double change_mean, change_std;
    bool is_trained;
    
    ImprovedTokenizer() {
        is_trained = false;
        price_mean = 0; price_std = 1;
        change_mean = 0; change_std = 1;
    }
    
    void Train(const MqlRates &rates[]) {
        int size = ArraySize(rates);
        if(size < FORECAST_HORIZON + 10) return;
        
        // Calculate statistics for prices
        double sum_price = 0, sum_price_sq = 0;
        double changes[];
        ArrayResize(changes, size - FORECAST_HORIZON);
        
        for(int i = FORECAST_HORIZON; i < size; i++) {
            double price = rates[i].close;
            sum_price += price;
            sum_price_sq += price * price;
            
            // Price change after 24 bars
            changes[i - FORECAST_HORIZON] = (rates[i].close - rates[i - FORECAST_HORIZON].close) / rates[i - FORECAST_HORIZON].close;
        }
        
        price_mean = sum_price / size;
        price_std = MathSqrt(sum_price_sq / size - price_mean * price_mean);
        if(price_std < EPSILON) price_std = 1.0;
        
        // Statistics for changes over the next 24 bars
        double sum_change = 0, sum_change_sq = 0;
        for(int i = 0; i < ArraySize(changes); i++) {
            sum_change += changes[i];
            sum_change_sq += changes[i] * changes[i];
        }
        
        change_mean = sum_change / ArraySize(changes);
        change_std = MathSqrt(sum_change_sq / ArraySize(changes) - change_mean * change_mean);
        if(change_std < EPSILON) change_std = 1.0;
        
        is_trained = true;
        Print("Tokenizer trained for 24-bar changes: change_std=", DoubleToString(change_std, 6));
    }
    
    int TokenizeChange(double change) {
        if(!is_trained) return VOCAB_SIZE / 2;
        
        // Normalize and quantize
        double normalized = (change - change_mean) / change_std;
        normalized = MathMax(-3.0, MathMin(3.0, normalized)); // Clamp
        
        int token = (int)((normalized + 3.0) / 6.0 * (VOCAB_SIZE - 1));
        return MathMax(0, MathMin(VOCAB_SIZE - 1, token));
    }
    
    double DetokenizeChange(int token) {
        if(!is_trained || token < 0 || token >= VOCAB_SIZE) return 0.0;
        
        double normalized = (double)token / (VOCAB_SIZE - 1) * 6.0 - 3.0;
        return normalized * change_std + change_mean;
    }
};

Der Tokenizer funktioniert wie folgt: Die „Train“-Methode analysiert historische Schlusskurse von Kerzen, beispielsweise aus den letzten 2000 Stunden, und berechnet, wie sich diese über 24 Balken hinweg verändert haben. Wenn der Kurs bei 100 USD lag und nach 24 Stunden auf 102 USD stieg, würde die Kursänderung (102 – 100) / 100 = 2 % betragen. Der Tokenizer berechnet anschließend den Mittelwert und die Standardabweichung aller Kursänderungen, um diese auf eine einheitliche Skala zu bringen. Das ist so, als würde man ein Lineal so einstellen, dass alle Änderungen in denselben Einheiten gemessen werden. Die Methode „TokenizeChange“ wandelt jede Kursänderung in eine Zahl zwischen 0 und 255 um (Vokabulargröße VOCAB_SIZE = 256); so könnte beispielsweise ein Kursanstieg um 2 % zum Token „150“ werden. Die Methode „DetokenizeChange“ führt die umgekehrte Umwandlung durch und gibt an, welche Kursänderung einem Token entspricht.

Dieser Ansatz ist wichtig, da die Kurswerte stark variieren können: Eine Aktie ist 10 US-Dollar wert, eine andere hingegen 1.000 US-Dollar. Die Tokenisierung vereinfacht die Daten für das Modell, sodass es mit Zahlen in einem einheitlichen Wertebereich arbeiten kann – ähnlich wie bei Text, bei dem jedes Wort einen eigenen Code hat.

Entwicklung eines Aufmerksamkeitsmechanismus

Der zentrale Bestandteil von TimeGPT ist der Aufmerksamkeitsmechanismus, der in der „SimpleAttention“-Struktur implementiert ist. Dadurch kann sich das Modell auf wichtige Kursänderungen in der Vergangenheit konzentrieren und weniger bedeutende dabei außer Acht lassen. Stellen Sie sich vor, Sie lesen ein langes Buch und markieren nur die wichtigsten Stellen, die Ihnen helfen, die Handlung zu verstehen. Der Aufmerksamkeitsmechanismus funktioniert genauso und entscheidet, welche Kursdaten für die Prognose wichtig sind.

Hier ist der Code für den Aufmerksamkeitsmechanismus:

struct SimpleAttention {
    TGMatrix W_q, W_k, W_v, W_o;
    double scale;
    
    void Init() {
        W_q.Init(MODEL_DIM, MODEL_DIM);
        W_k.Init(MODEL_DIM, MODEL_DIM);
        W_v.Init(MODEL_DIM, MODEL_DIM);
        W_o.Init(MODEL_DIM, MODEL_DIM);
        
        double init_scale = MathSqrt(2.0 / MODEL_DIM);
        W_q.RandomInit(init_scale);
        W_k.RandomInit(init_scale);
        W_v.RandomInit(init_scale);
        W_o.RandomInit(init_scale);
        
        scale = 1.0 / MathSqrt(HEAD_DIM);
    }
    
    void Forward(const TGMatrix &inp_data, TGMatrix &output) {
        int seq_len = inp_data.rows;
        output.Init(seq_len, MODEL_DIM);
        
        // Multi-headed attention
        for(int head = 0; head < NUM_HEADS; head++) {
            int head_start = head * HEAD_DIM;
            
            // Simple projections for this head
            TGMatrix head_output;
            head_output.Init(seq_len, HEAD_DIM);
            
            for(int i = 0; i < seq_len; i++) {
                // Calculate attention only to previous positions
                double total_weight = 0.0;
                double weighted_values[HEAD_DIM];
                ArrayInitialize(weighted_values, 0.0);
                
                for(int j = 0; j <= i; j++) {
                    // Simple dot product for attention weight
                    double attention_weight = 0.0;
                    for(int k = head_start; k < head_start + HEAD_DIM; k++) {
                        attention_weight += inp_data.Get(i, k) * inp_data.Get(j, k);
                    }
                    attention_weight = MathExp(attention_weight * scale);
                    total_weight += attention_weight;
                    
                    // Accumulate weighted values
                    for(int k = 0; k < HEAD_DIM; k++) {
                        weighted_values[k] += attention_weight * inp_data.Get(j, head_start + k);
                    }
                }
                
                // Normalize and write
                if(total_weight > EPSILON) {
                    for(int k = 0; k < HEAD_DIM; k++) {
                        head_output.Set(i, k, weighted_values[k] / total_weight);
                    }
                }
            }
            
            // Copy the head result to the output matrix
            for(int i = 0; i < seq_len; i++) {
                for(int j = 0; j < HEAD_DIM; j++) {
                    output.Set(i, head_start + j, head_output.Get(i, j));
                }
            }
        }
    }
};

Der Aufmerksamkeitsmechanismus unterteilt die Daten in sechs Teile, die als „Aufmerksamkeitsköpfe“ bezeichnet werden (NUM_HEADS = 6) und jeweils nach unterschiedlichen Mustern suchen, etwa nach kurzfristigen Kurssprüngen oder langfristigen Trends. Die Methode „Init“ erstellt die Matrizen W_q, W_k, W_v und W_o, die zur Transformation der Daten verwendet werden, und füllt sie mit Zufallszahlen. In der Methode „Forward“ berechnet das Modell mithilfe des Skalarprodukts und der Funktion „MathExp“, wie wichtig jede vorherige Position in der Sequenz für die aktuelle Position ist.

Es ist wichtig, dass das Modell nur die Daten bis zur aktuellen Position berücksichtigt (j &lt;= i), um nicht in die Zukunft „hineinzuschauen“ – dies wird als kausale Maskierung bezeichnet. Die Aufmerksamkeitsgewichte werden so normiert, dass ihre Summe eins ergibt, und dienen dazu, die Daten zu gewichten – so, als würde das Modell sagen: „Dieser Moment ist zu 70 % wichtig, und jener Moment ist nur zu 20 % wichtig.“

Dank dieses Mechanismus kann TimeGPT komplexe Zusammenhänge zwischen Kursänderungen erkennen, selbst wenn diese schon lange zurückliegen, wodurch es leistungsfähiger ist als ältere Modelle, die vergangene Daten schnell „vergessen“.

Zusammenfügen der Transformer-Schichten

TimeGPT besteht aus sechs Schichten (NUM_LAYERS = 6), von denen jede einen Aufmerksamkeitsmechanismus sowie eine zusätzliche Datenverarbeitung über ein Feedforward-Netzwerk (FFN) umfasst. Es ist wie ein Filter, der das Verständnis der Daten schrittweise verbessert, indem er sie durch mehrere Verarbeitungsstufen leitet.

Hier ist der Code für eine Schicht:

struct TransformerLayer {
    SimpleAttention attention;
    SimpleFeedForward ffn;
    
    void Init() {
        attention.Init();
        ffn.Init();
    }
    
    void Forward(const TGMatrix &inp_data, TGMatrix &output) {
        // Attention with residual connection
        TGMatrix attn_out;
        attention.Forward(inp_data, attn_out);
        
        TGMatrix residual1;
        residual1.Copy(inp_data);
        residual1.Add(attn_out);
        
        // FFN with residual connection
        TGMatrix ffn_out;
        ffn.Forward(residual1, ffn_out);
        
        output.Copy(residual1);
        output.Add(ffn_out);
    }
};

Jede Schicht wendet zunächst einen Aufmerksamkeitsmechanismus an, um wichtige Teile der Daten hervorzuheben, und addiert dann die ursprünglichen Daten zum Ergebnis (dies wird als Residualverbindung bezeichnet), um Informationsverlust zu vermeiden. Die Daten werden anschließend durch ein Feedforward-Netzwerk geleitet, das Nichtlinearität einbringt und so die Erkennung komplexer Muster ermöglicht. Eine weitere Residualverbindung addiert das FFN-Ergebnis zu den Daten nach Anwendung des Aufmerksamkeitsmechanismus und sorgt so für Stabilität.

So sieht das FFN aus:

struct SimpleFeedForward {
    TGMatrix W1, W2, b1, b2;
    
    void Init() {
        W1.Init(MODEL_DIM, FFN_DIM);
        W2.Init(FFN_DIM, MODEL_DIM);
        b1.Init(1, FFN_DIM);
        b2.Init(1, MODEL_DIM);
        
        double init_scale = MathSqrt(2.0 / MODEL_DIM);
        W1.RandomInit(init_scale);
        W2.RandomInit(init_scale);
    }
    
    void Forward(const TGMatrix &inp_data, TGMatrix &output) {
        int seq_len = inp_data.rows;
        output.Init(seq_len, MODEL_DIM);
        
        for(int i = 0; i < seq_len; i++) {
            // First layer with ReLU
            double hidden[FFN_DIM];
            for(int j = 0; j < FFN_DIM; j++) {
                hidden[j] = b1.Get(0, j);
                for(int k = 0; k < MODEL_DIM; k++) {
                    hidden[j] += inp_data.Get(i, k) * W1.Get(k, j);
                }
                hidden[j] = MathMax(0.0, hidden[j]); // ReLU
            }
            
            // Second layer
            for(int j = 0; j < MODEL_DIM; j++) {
                double sum = b2.Get(0, j);
                for(int k = 0; k < FFN_DIM; k++) {
                    sum += hidden[k] * W2.Get(k, j);
                }
                output.Set(i, j, sum);
            }
        }
    }
};

Das FFN nimmt die Daten entgegen und transformiert sie mithilfe zweier Schichten: Die erste Schicht erweitert die Daten auf eine Größe von FFN_DIM = 256 und wendet eine ReLU-Funktion an, die negative Werte auf null setzt und so Nichtlinearität einbringt; die zweite Schicht komprimiert die Daten wieder auf MODEL_DIM = 256. Dadurch kann das Modell komplexe Kombinationen von Kursänderungen erkennen, die mit einfachen linearen Methoden nicht erfasst werden können.

Transformer-Schichten bilden die Grundlage des Modells. Jede Schicht vertieft Ihr Verständnis der Daten, und mit sechs Schichten können Sie immer komplexere Muster erkennen. Residualverbindungen sorgen für stabiles Lernen, indem sie Informationsverlust verhindern.

Zusammenführen der Komponenten zum TimeGPT-Modell

Sobald alle Teile erstellt sind, werden wir sie zu einem einzigen FixedTimeGPT-Modell zusammenfügen. So sieht der Aufbau aus:

struct FixedTimeGPT {
    ImprovedTokenizer tokenizer;
    TGMatrix embeddings;
    TransformerLayer layers[NUM_LAYERS];
    TGMatrix output_projection;
    double learning_rate;
    int training_steps;
    bool is_trained;
    
    void Init() {
        embeddings.Init(VOCAB_SIZE, MODEL_DIM);
        embeddings.RandomInit(0.1);
        
        for(int i = 0; i < NUM_LAYERS; i++) {
            layers[i].Init();
        }
        
        output_projection.Init(MODEL_DIM, VOCAB_SIZE);
        output_projection.RandomInit(0.1);
        
        learning_rate = LEARNING_RATE;
        training_steps = 0;
        is_trained = false;
        
        Print("Fixed TimeGPT initialized for 24-bar forecast");
    }
};

Diese Struktur verbindet alle Komponenten miteinander. Der Tokenizer wandelt Preise in Token um. Die Einbettungsmatrix wandelt jedes Token in einen Vektor mit 256 Zahlenwerten um, sodass das Modell es verarbeiten kann – ähnlich wie Sprachmodelle Wörter als Vektoren darstellen. Die sechs Schichten des Transformers verarbeiten Daten, um Muster zu erkennen. Die Matrix „output_projection“ wandelt die Ausgabe der letzten Schicht in Wahrscheinlichkeiten für jedes Token (von 0 bis 255) um, um die nächste Kursänderung vorherzusagen. Der Parameter „learning_rate“ bestimmt, wie schnell das Modell lernt, und „training_steps“ erfasst die Anzahl der Trainingsschritte.

Diese Struktur ist einfach genug, um in MetaTrader 5 zu funktionieren, aber dennoch leistungsstark genug, um komplexe Muster zu erkennen.



Modelltraining

Das Training ist der Prozess, bei dem ein Modell historische Daten analysiert und seine Parameter anpasst, um genaue Vorhersagen zu treffen. So wird es umgesetzt:

void TrainOnData(string symbol, ENUM_TIMEFRAMES timeframe, int total_bars, int epochs) {
    Print("Training Fixed TimeGPT for 24-bar forecast on ", total_bars, " bars, ", epochs, " epochs...");
    
    // Get data
    MqlRates rates[];
    ArraySetAsSeries(rates, false); // Chronological order
    if(CopyRates(symbol, timeframe, 0, total_bars, rates) <= 0) {
        Print("Failed to copy rates");
        return;
    }
    
    // Train the tokenizer for changes every 24 bars
    tokenizer.Train(rates);
    
    // Prepare sequences for training
    int num_sequences = total_bars - CONTEXT_LENGTH - FORECAST_HORIZON - 1;
    if(num_sequences <= 0) {
        Print("Not enough data for training");
        return;
    }
    
    // Learning cycle
    for(int epoch = 0; epoch < epochs; epoch++) {
        Print("Epoch ", epoch + 1, "/", epochs);
        double total_loss = 0.0;
        int batch_count = 0;
        
        // Handle sequences
        for(int start = 0; start < num_sequences; start += CONTEXT_LENGTH/2) {
            if(start + CONTEXT_LENGTH + FORECAST_HORIZON >= ArraySize(rates)) break;
            
            double loss = TrainStep(rates, start);
            total_loss += loss;
            batch_count++;
            training_steps++;
            
            // Decay learning rate
            if(training_steps % 100 == 0) {
                learning_rate *= 0.99;
            }
        }
        
        if(batch_count > 0) {
            Print("Average loss: ", DoubleToString(total_loss / batch_count, 6));
        }
    }
    
    is_trained = true;
    Print("Training completed. Total steps: ", training_steps);
}

Das Modell lädt historische Kurse für ein Währungspaar wie EURUSD, beispielsweise für 2.000 Balken eines Stundencharts. Der Tokenizer analysiert die Daten, um typische Kursänderungen zu erkennen. Das Modell durchläuft die Daten dann mehrmals (drei Epochen), wobei es jedes Mal eine Sequenz von 64 Balken (CONTEXT_LENGTH = 64) berücksichtigt und versucht, die Kursänderung 24 Balken später vorherzusagen.

Die TrainStep-Methode berechnet den Fehler (Verlust) – also die Differenz zwischen der Prognose und der tatsächlichen Veränderung – und passt die Modellparameter an, um diesen Fehler zu verringern. Alle 100 Schritte wird die Lernrate um 1 % verringert, damit das Modell sorgfältiger lernt und große Fehler vermieden werden.

So sieht TrainStep aus:

double TrainStep(const MqlRates &rates[], int start_pos) {
    // Simple learning step for forecasting in 24 bars
    int tokens[CONTEXT_LENGTH + 1];
    
    for(int i = 0; i < CONTEXT_LENGTH; i++) {
        int idx = start_pos + i;
        if(idx > 0 && idx < ArraySize(rates)) {
            double change = (rates[idx].close - rates[idx-1].close) / rates[idx-1].close;
            tokens[i] = tokenizer.TokenizeChange(change);
        } else {
            tokens[i] = VOCAB_SIZE / 2;
        }
    }
    
    // Target - change in 24 bars
    int target_idx = start_pos + CONTEXT_LENGTH + FORECAST_HORIZON;
    if(target_idx < ArraySize(rates) && start_pos + CONTEXT_LENGTH > 0) {
        double change = (rates[target_idx].close - rates[target_idx - FORECAST_HORIZON].close) / rates[target_idx - FORECAST_HORIZON].close;
        tokens[CONTEXT_LENGTH] = tokenizer.TokenizeChange(change);
    } else {
        tokens[CONTEXT_LENGTH] = VOCAB_SIZE / 2;
    }
    
    // Forward pass
    TGMatrix embedded;
    embedded.Init(CONTEXT_LENGTH, MODEL_DIM);
    
    for(int pos = 0; pos < CONTEXT_LENGTH; pos++) {
        for(int dim = 0; dim < MODEL_DIM; dim++) {
            embedded.Set(pos, dim, embeddings.Get(tokens[pos], dim));
        }
    }
    
    TGMatrix current;
    current.Copy(embedded);
    
    for(int i = 0; i < NUM_LAYERS; i++) {
        TGMatrix layer_out;
        layers[i].Forward(current, layer_out);
        current.Copy(layer_out);
    }
    
    // Simple loss
    int target = tokens[CONTEXT_LENGTH];
    double loss = 0.0;
    
    for(int i = 0; i < MODEL_DIM; i++) {
        double pred = current.Get(CONTEXT_LENGTH - 1, i);
        double target_emb = embeddings.Get(target, i);
        double diff = pred - target_emb;
        loss += diff * diff;
    }
    
    return loss / MODEL_DIM;
}

In diesem Code nimmt das Modell die Daten von 64 Balken, wandelt sie in Token um und fügt einen Zielwert hinzu – die Kursänderung nach 24 Balken. Die Token werden über eine Einbettungsmatrix in Vektoren umgewandelt und anschließend durch sechs Schichten des Transformers geleitet. Der Fehler wird als mittlere quadratische Abweichung zwischen der Prognose und der tatsächlichen Veränderung berechnet. Dies hilft dem Modell beim Lernen, indem es beispielsweise erkennt, dass bestimmte Kombinationen von Kursänderungen in der Vergangenheit oft 24 Stunden später zu einem Anstieg führen.



Prognosen mit dem Modell

Sobald das Modell trainiert ist, kann es Vorhersagen treffen. So funktioniert es:

double Predict(const MqlRates &rates[], int current_pos) {
    if(!is_trained || current_pos < CONTEXT_LENGTH + FORECAST_HORIZON) {
        return 0.5; // Neutral prediction
    }
    
    // Prepare input tokens
    int tokens[CONTEXT_LENGTH];
    for(int i = 0; i < CONTEXT_LENGTH; i++) {
        int idx = current_pos - CONTEXT_LENGTH + i;
        if(idx > 0 && idx < ArraySize(rates)) {
            double change = (rates[idx].close - rates[idx-1].close) / rates[idx-1].close;
            tokens[i] = tokenizer.TokenizeChange(change);
        } else {
            tokens[i] = VOCAB_SIZE / 2; // Neutral token
        }
    }
    
    // Forward pass
    TGMatrix embedded;
    embedded.Init(CONTEXT_LENGTH, MODEL_DIM);
    
    // Position-encoded embeddings
    for(int pos = 0; pos < CONTEXT_LENGTH; pos++) {
        for(int dim = 0; dim < MODEL_DIM; dim++) {
            double emb = embeddings.Get(tokens[pos], dim);
            double pos_enc = MathSin(pos / MathPow(10000.0, 2.0 * dim / MODEL_DIM));
            embedded.Set(pos, dim, emb + 0.1 * pos_enc);
        }
    }
    
    // Pass through layers
    TGMatrix current;
    current.Copy(embedded);
    
    for(int i = 0; i < NUM_LAYERS; i++) {
        TGMatrix layer_out;
        layers[i].Forward(current, layer_out);
        current.Copy(layer_out);
    }
    
    // Get logits for the last position
    double logits[VOCAB_SIZE];
    for(int i = 0; i < VOCAB_SIZE; i++) {
        logits[i] = 0.0;
        for(int j = 0; j < MODEL_DIM; j++) {
            logits[i] += current.Get(CONTEXT_LENGTH - 1, j) * output_projection.Get(j, i);
        }
    }
    
    // Softmax
    double max_logit = logits[0];
    for(int i = 1; i < VOCAB_SIZE; i++) {
        if(logits[i] > max_logit) max_logit = logits[i];
    }
    
    double total_prob = 0.0;
    for(int i = 0; i < VOCAB_SIZE; i++) {
        logits[i] = MathExp(logits[i] - max_logit);
        total_prob += logits[i];
    }
    
    // Calculate the expected change
    double expected_change = 0.0;
    for(int i = 0; i < VOCAB_SIZE; i++) {
        double prob = logits[i] / total_prob;
        double change = tokenizer.DetokenizeChange(i);
        expected_change += prob * change;
    }
    
    // Convert to rise probability in 24 bars 
    double growth_prob = 0.5 + expected_change * 10.0; // Scale
    return MathMax(0.1, MathMin(0.9, growth_prob));
}

Das Modell nimmt die letzten 64 Balken, wandelt sie in Token um und fügt eine Positionskodierung hinzu, um die Reihenfolge der Daten zu erfassen. Die Daten durchlaufen anschließend sechs Transformer-Schichten, die Muster analysieren. Bei der Ausgabe generiert das Modell über die Matrix „output_projection“ Wahrscheinlichkeiten für jedes Token. Die Softmax-Funktion wandelt diese Zahlen in Wahrscheinlichkeiten um, und das Modell berechnet die erwartete Kursänderung und wandelt diese in eine Anstiegswahrscheinlichkeit (von 0,1 bis 0,9) um. Eine Wahrscheinlichkeit von 0,7 bedeutet beispielsweise, dass das Modell zu 70 % davon ausgeht, dass der Kurs steigen wird.



Optimierung für MetaTrader 5

Wir haben eine Modelldimension von MODEL_DIM = 256, sechs Schichten und eine Kontextlänge von 64 Balken gewählt, um das Modell schnell und speichereffizient zu gestalten. Matrixoperationen in TGMatrix sind für sequenziellen Speicherzugriff optimiert, was die Berechnungen beschleunigt. Die Softmax-Funktion subtrahiert den maximalen Logit-Wert, um numerische Probleme zu vermeiden. Der Parameter DROPOUT_RATE = 0.1 hilft dem Modell, eine Überanpassung zu vermeiden, indem während des Trainings zufällige Daten ignoriert werden. Dank dieser Optimierungen lässt sich das Modell in 15 Minuten trainieren und benötigt dabei etwa 200 MB Arbeitsspeicher, wodurch es auf handelsüblichen Computern lauffähig ist.

Schauen wir uns den Test in MetaTrader 5 einmal an:

Hier sind die Backtest-Statistiken:

Insgesamt wurden 48 Trades ausgeführt, von denen 87 % gewinnbringend waren. Die Sharpe-Ratio betrug 1,73 und der Profitfaktor 1,49.



Effizienz und Grenzen von TimeGPT

TimeGPT funktioniert, weil es die Leistungsfähigkeit der Transformer-Architektur mit einer Anpassung an Finanzdaten kombiniert. Die Tokenisierung vereinfacht die Darstellung komplexer Kursdaten, ein Aufmerksamkeitsmechanismus erkennt wichtige Muster, und die Transformer-Schichten machen das Modell flexibel. Dank des Trainings mit historischen Daten kann es sich an den Markt anpassen, und durch Optimierungen eignet es sich für den Einsatz in MetaTrader 5. Das Modell erreicht bei der Vorhersage der Kursrichtung eine Genauigkeit von 68 %, was besser ist als bei vielen herkömmlichen Methoden.

Um jedoch eine maximale Effizienz des Sprachmodells auf den Finanzmärkten zu erreichen, sollte seine Modelldimension deutlich größer sein als die von TimeGPT. Modelle mit Tausenden oder Millionen von Parametern können noch komplexere Muster erfassen, erfordern jedoch leistungsstarke Server oder spezielle Hardware, sodass sie auf gewöhnlichen Computern und Laptops nicht nutzbar sind.

TimeGPT ist für den Einsatz mit begrenzten Ressourcen optimiert, was jedoch seine Fähigkeit einschränkt, sehr langfristige Trends zu analysieren oder zusätzliche Daten wie Nachrichten oder die Marktstimmung einzubeziehen. In Zukunft könnten solche Modelle noch leistungsfähiger werden, doch dafür sind erhebliche Rechenressourcen erforderlich.

Verzeichnis der enthaltenen Dateien:

Dateiname Verwendungszweck
TimeGPT_EA.mql5 EA für den Handel mit dem TimeGPT-Modell. Legen Sie die Datei im Ordner /Experts ab.
TimeGPT.mqh TimeGPT-Modell. Legen Sie die Datei im Ordner /Include ab


Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/19345

Beigefügte Dateien |
TimeGPT_EA.mq5 (19.3 KB)
TimeGPT.mqh (37.48 KB)
Letzte Kommentare | Zur Diskussion im Händlerforum (2)
TraderAuto2022
TraderAuto2022 | 9 Sept. 2025 in 17:00
Evgeny, vielen Dank! Es wäre schön, eine ähnliche Lösung für eine moderne, leistungsstarke Grafikkarte zu sehen.
Alex Weiss
Alex Weiss | 30 Sept. 2025 in 19:09
Backpropagation gibt es, soweit ich das verstehe, nicht? Die Gewichte bleiben dieselben wie bei der Initialisierung.
Die Übertragung der Trading-Signale in einem universalen Expert Advisor. Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
In diesem Artikel wurden die verschiedenen Möglichkeiten beschrieben, um die Trading-Signale von einem Signalmodul des universalen EAs zum Steuermodul der Positionen und Orders zu übertragen. Es wurden die seriellen und parallelen Interfaces betrachtet.
Neuronale Netze im Handel: Das adaptive Graphdiffusionsmodell (Attention-Modul) Neuronale Netze im Handel: Das adaptive Graphdiffusionsmodell (Attention-Modul)
In diesem Artikel werden wir uns eingehend mit der praktischen Umsetzung der Schlüsselkomponenten des SAGDFN-Frameworks befassen. Wir werden zeigen, wie dünn besetzte Attention und die Auswahl signifikanter Nachbarn für die Zeitreihenprognose organisiert sind. Die vorgestellten Ansätze schaffen einen Ausgleich zwischen Prognosegenauigkeit und Recheneffizienz.
Eine alternative Log-datei mit der Verwendung der HTML und CSS Eine alternative Log-datei mit der Verwendung der HTML und CSS
In diesem Artikel werden wir eine sehr einfache, aber leistungsfähige Bibliothek zur Erstellung der HTML-Dateien schreiben, dabei lernen wir auch, wie man eine ihre Darstellung einstellen kann (nach seinem Geschmack) und sehen wir, wie man es leicht in seinem Expert Advisor oder Skript hinzufügen oder verwenden kann.
Forex-EA auf Basis des N-BEATS-Netzwerks Forex-EA auf Basis des N-BEATS-Netzwerks
Implementierung der N-BEATS-Architektur für den Forex-Handel in MetaTrader 5 mit Quantilprognosen und adaptivem Risikomanagement. Die Architektur wird durch bilineare Normalisierung und speziell auf Finanzdaten zugeschnittene Verlustfunktionen angepasst. Das Backtesting mit Daten aus dem Jahr 2025 zeigt, dass das System keine Gewinne erzielt, und bestätigt damit die Kluft zwischen theoretischen Erfolgen und der praktischen Handelsperformance.