English Русский Español Português
preview
基于 GPT 语言模型的交易机器人

基于 GPT 语言模型的交易机器人

MetaTrader 5 — 交易系统 |
58 2
Yevgeniy Koshtenko
Yevgeniy Koshtenko

引言

TimeGPT 是一个机器学习模型,用于在 MetaTrader 5 平台上预测金融市场(如外汇货币对或股票)的价格走势。它基于 Transformer 架构。该架构最初是为处理文本(如翻译或文本生成)而设计的,现在则被适配用于金融数据分析。在本文中,我将详细说明 TimeGPT 是如何逐步创建的,涵盖其架构、数据处理、训练和预测。所有内容都将用通俗的语言配合类比来解释,即使只是刚开始学习机器学习的人也能理解这样一个模型是如何创建的。最后,我还会谈及该模型的局限性及其计算资源需求。

创建一个像 TimeGPT 这样的模型需要哪些条件?

在深入代码之前,重要的是先理解 TimeGPT 处理的是什么。金融市场以时间序列的形式产生数据,即以固定间隔(例如每小时)记录的一系列价格。市场价格并不遵循简单的规则:它们可能因新闻而暴涨、缓慢下跌,或无缘无故地波动。TimeGPT 的任务是在这些数据中寻找规律,并预测价格在 24 小时后将如何变化。在市场图表的术语中,这称为 24 根 K 线。

开发一个模型需要解决几个问题。首先,我们需要确定如何存储和处理价格数据。然后,我们需要将这些数据转换为模型能够理解的格式。接着,我们需要设计模型架构,使其能够发现数据中的复杂依赖关系。随后,让模型基于历史数据进行训练,学习如何做出准确预测。最后,考虑到 MetaTrader 5 平台的限制,优化模型使其运行迅速且不会占用过多内存也很重要。现在,让我们通过 TimeGPT_Fixed.mqh 文件中的代码逐一查看这些步骤。



模型开发

创建用于处理数据的结构

开发 TimeGPT 的第一步是创建一个用于存储和处理数据的结构。在机器学习中,数据通常表示为矩阵,即便于进行数学运算的数字表格。为此,TimeGPT 中创建了 TGMatrix 结构,它允许以有序形式存储价格或模型参数等数字。

该结构的代码如下:

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;
        }
    }
};

可以将 TGMatrix 想象成一张 Excel 表格,其中的数字按行和列存储。Init 方法创建所需大小的表格;Get 和 Set 允许读取和写入特定单元格的值;RandomInit 用随机数填充表格,这些随机数是模型初始设置所需的;Add、Copy 和 Scale 方法则执行基本操作,例如将两张表相加或将所有数字乘以某个值。这一结构成为 TimeGPT 中处理数据的基础,因为所有价格、模型参数和计算都使用矩阵。我们选择这种方法是因为它简单,并且在 MetaTrader 5 中运行良好;在该平台中无法使用像 Python 那样的复杂库。

将价格转换为模型可理解的格式

为了让模型能够分析价格,需要将其转换为一种方便的格式。TimeGPT 借鉴了文本处理中的一个思路:每个价格变化都被转换为一个 "token"(标记),即一个代表价格变动的数字,例如上涨 0.5% 或下跌 0.3%。ImprovedTokenizer 结构负责此事。

这是它的代码:

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;
    }
};

令牌化器的工作方式如下。Train 方法分析历史 K 线的收盘价(例如最近 2000 小时的数据),并计算它们在 24 根 K 线内的变化。如果价格是 100 美元,24 小时后变为 102 美元,则变化为 (102 - 100) / 100 = 2%。然后,令牌化器计算所有变化的均值和标准差,将它们统一到同一尺度。这就像调整一把尺子,使所有变化都以相同的单位来衡量。TokenizeChange 方法将每个变化转换为 0 到 255 之间的数字(词表大小 VOCAB_SIZE = 256),例如,2% 的上涨可能变为 token "150"。DetokenizeChange 方法执行反向转换,指出某个 token 对应哪个价格变化。

这种方法很重要,因为原始价格的差异可能非常大:一只股票价值 10 美元,而另一只可能价值 1000 美元。令牌化使数据对模型来说更简单,使其能在单一数值范围内处理数字,就像文本一样:文本中每个词都有自己的编码。

构建注意力机制

TimeGPT 的关键部分是实现在 SimpleAttention 结构中的注意力机制。它允许模型关注过去重要的价格变化,同时忽略不那么重要的变化。想象一下读一本很长的书,只标出那些帮助你理解情节的关键点。注意力机制做的事情是一样的:它决定哪些价格数据对预测是重要的。

以下是注意力机制的代码:

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));
                }
            }
        }
    }
};

注意力机制将数据分成六个部分,称为 "头"(heads,NUM_HEADS = 6),每个头寻找不同的模式,例如短期价格尖峰或长期趋势。Init 方法创建用于转换数据的 W_q、W_k、W_v 和 W_o 矩阵,并用随机数初始化它们。在 Forward 方法中,模型使用点积和 MathExp 函数计算序列中每个先前位置对当前位置的重要程度。

重要的是,模型只查看截至当前位置的数据(j <= i),以免 "窥视" 未来,这称为因果掩码。注意力权重经过归一化,使其总和为 1,并用于对数据加权,就好像模型在说:"这一刻的重要性是 70%,那一刻只有 20%。"

这一机制使 TimeGPT 能够发现价格变化之间的复杂关系,即使这些变化发生在很久以前,这使它比那些很快 "忘记" 历史数据的旧模型更强大。

组装 Transformer 层

TimeGPT 由六层组成(NUM_LAYERS = 6),每层都包含一个注意力机制,以及通过前馈网络(FFN)进行的额外数据处理。它就像一个过滤器,经过若干处理阶段逐步提升对数据的理解。

以下是其中一层的代码:

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);
    }
};

每一层首先应用注意力机制来突出数据中的重要部分,然后将原始数据加到结果中(这称为残差连接),以避免信息丢失。随后数据通过前馈网络,该网络增加了非线性,从而能够发现复杂的模式。另一个残差连接将 FFN 的结果加到经过注意力处理后的数据上,从而保持稳定性。

FFN 的样子如下:

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);
            }
        }
    }
};

FFN 接收数据并通过两层进行变换:第一层将数据扩展到 FFN_DIM = 256 的维度,并应用 ReLU 函数将负值置零,从而增加非线性;第二层将数据压缩回 MODEL_DIM = 256。这有助于模型检测简单线性方法无法看到的复杂价格变化组合。

Transformer 层是模型的基础。每一层都增强对数据的理解,而六层允许捕捉日益复杂的模式。残差连接通过防止信息丢失使学习保持稳定。

将各组件组合成 TimeGPT 模型

所有部件创建完成后,我们将它们组装成一个单一的 FixedTimeGPT 模型。其结构如下:

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");
    }
};

这一结构将所有组件整合在一起。令牌化器将价格转换为 token。嵌入(embeddings)矩阵将每个 token 转换为一个 256 维的数值向量,使模型能够像语言模型表示单词那样处理它。Transformer 的六层处理数据以寻找模式。output_projection 矩阵将最后一层的输出转换为每个 token(0 到 255)的概率,以预测下一个价格变化。learning_rate 参数决定模型学习的速度,training_steps 跟踪训练步数。

这一结构足够简单,可以在 MetaTrader 5 上运行,但仍足够强大,能够发现复杂的模式。



模型训练

训练是模型分析历史数据并调整其参数以做出准确预测的过程。其实现方式如下:

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);
}

模型加载历史价格,例如在小时图上加载 2000 根 K 线的数据,交易品种如 EURUSD。令牌化器分析数据以理解典型的价格变化。然后模型多次遍历数据(三个 epoch),每次取一段 64 根 K 线的序列(CONTEXT_LENGTH = 64),并尝试预测 24 根 K 线之后的价格变化。

TrainStep 方法计算误差(loss),即预测值与实际变化之间的差异,并调整模型参数以减小这一误差。每 100 步,学习率降低 1%,使模型学习得更加谨慎,避免出现大的误差。

TrainStep 的样子如下:

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;
}

在这段代码中,模型取 64 根 K 线的数据,将其转换为 token,并添加一个目标,即 24 根 K 线后的价格变化。token 通过嵌入矩阵转换为向量,然后经过六层 Transformer。误差按预测值与实际变化之间的均方偏差计算。这有助于模型学习,例如注意到过去某些价格变化组合往往会在 24 小时后导致上涨。



使用模型进行预测

训练完成后,模型就准备好进行预测了。其工作方式如下:

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));
}

模型取最近 64 根 K 线,将其转换为 token,并加入位置编码,以了解数据的顺序。然后数据经过六层 Transformer 分析其中的模式。在输出端,模型通过 output_projection 矩阵为每个 token 生成概率。Softmax 函数将这些数字转换为概率,模型计算出预期价格变化,并将其转换为上涨概率(从 0.1 到 0.9)。例如,概率 0.7 意味着模型有 70% 的把握认为价格将上涨。



针对 MetaTrader 5 的优化

我们选择模型维度 MODEL_DIM = 256、六层结构以及 64 根 K 线的上下文长度,以使模型快速且内存高效。TGMatrix 中的矩阵运算针对顺序内存访问进行了优化,从而加速计算。Softmax 函数减去最大 logit 值,以避免数值问题。DROPOUT_RATE = 0.1 参数通过在训练期间忽略随机数据,帮助模型避免过拟合。这些优化使模型能在 15 分钟内完成训练,并使用约 200MB 内存,从而对普通计算机来说也可用。

让我们看看在 MetaTrader 5 中的测试:

以下是回测统计数据:

共执行了 48 笔交易,其中 87% 是盈利的。夏普比率为 1.73,盈利因子为 1.49。



TimeGPT 的效率与局限

TimeGPT 之所以有效,是因为它结合了 Transformer 架构的强大能力以及对金融数据的适配。令牌化简化了复杂的价格,注意力机制找到了重要的模式,而 Transformer 层使模型更灵活。基于历史数据的训练使其能够适应市场,而各项优化使其在 MetaTrader 5 中具备实用性。该模型在预测价格方向方面达到 68% 的准确率,这优于许多传统方法。

然而,要使语言模型在金融市场中发挥最大效率,其维度应显著大于 TimeGPT。拥有数千或数百万参数的模型能够捕捉更复杂的模式,但需要强大的服务器或专用硬件,使这类模型难以在普通台式机或笔记本电脑上使用。

TimeGPT 经过优化,可在有限资源上运行,但这限制了它分析非常长期趋势,或整合新闻、市场情绪等额外数据的能力。未来,此类模型可能会变得更加强大,但这将需要大量的计算资源。

包含文件表:

文件名 用途
TimeGPT_EA.mql5 使用 TimeGPT 模型进行交易的 EA。放置在 /Experts 目录 
TimeGPT.mqh TimeGPT 模型。放置在 /Include 目录


本文由MetaQuotes Ltd译自俄文
原文地址: https://www.mql5.com/ru/articles/19345

附加的文件 |
TimeGPT_EA.mq5 (19.3 KB)
TimeGPT.mqh (37.48 KB)
最近评论 | 前往讨论 (2)
TraderAuto2022
TraderAuto2022 | 9 9月 2025 在 17:00
叶夫根尼,谢谢您!如果能看到针对现代高性能显卡的类似解决方案就好了。
Alex Weiss
Alex Weiss | 30 9月 2025 在 19:09
Backprop,据我理解,是不存在的?权重保持初始化时的值不变。
交易策略 交易策略
各种交易策略的分类都是任意的,下面这种分类强调从交易的基本概念上分类。
市场模拟:仓位视图(五) 市场模拟:仓位视图(五)
尽管前一篇文章已经有所展示,这一切乍一看似乎很简单。实际上,仍存在几个问题,以及许多尚待完成的任务。亲爱的读者,你可能会认为一切都很简单明了。由于缺乏经验,你可能会简单地接受任何呈现给你的东西。而这是一个你应该尽力避免的错误。更糟糕的是,试图在不真正理解所使用内容的情况下使用它。初学者通常会经历一个复制粘贴的阶段。如果你不想永远停留在这一阶段,你应该学会如何使用某些工具。程序员最常用的工具之一是文档。其次是测试,辅以日志文件。接下来,我们将探讨如何做到这一点。
新手在交易中的10个基本错误 新手在交易中的10个基本错误
新手在交易中会犯的10个基本错误: 在市场刚开始时交易, 获利时不适当地仓促, 在损失的时候追加投资, 从最好的仓位开始平仓, 翻本心理, 最优越的仓位, 用永远买进的规则进行交易, 在第一天就平掉获利的仓位,当发出建一个相反的仓位警示时平仓, 犹豫。
交易中的神经网络:异质性感知元参数学习(HimNet) 交易中的神经网络:异质性感知元参数学习(HimNet)
我们诚邀您探索HimNet框架,该框架将时空自适应的灵活性与高计算效率相结合,能够对金融时间序列进行准确且稳定的预测。 本文详细阐述了其关键组件之间如何相互作用,从而将复杂的算法转化为易于管理的架构。