DLLを使わずにMetaTrader 5で直接OpenCLを使ってできることは次のとおりです。 - ページ 4

 
Alexey Volchanskiy:
そうですね、OCLはちょっと詳しいですね、意識はしています。EA全体をマップに読み込ませる必要はなく、いくつかの並列コードフラグメントを読み込ませて、それらは通常、コード全体の何パーセントかです。
そうすると、標準的なExpert Advisorでは大幅なスピードアップは望めません。全てはエージェントの帯域幅に制限されます。
 
Vitalie Postolache:
では、NVIDIA 780GTXを搭載しているのに、最適化の際にCPUコア(Core i5、8コア-8エージェント)しか表示されないのはなぜでしょうか?

あなたのコードではOpenCLを使用していますか?

ほとんどの場合、あなたのコードのどれかがグラフィックカードにロードされるべきだと考えています。というと、そうではありません。

MetaTrader 5のOpenCLに関する記事で、その仕組みについて詳しく説明していますので、ぜひお読みください。

 

大幅な高速化を実現するには、アドバイザー全体をGPUに送信する必要がありますが、そのためには独自のテスターを作成する必要があります。

このようなテスター、トレーディングロジックを備えたニューラルネットワーク、OCLコードの例を次に示します。

//————————————————————————————————————————————————————————————————————————————————————————————————
//Функция для ядра
string GPU_kernel( int hl1NeuronCount,
                   int hl2NeuronCount,
                   int sampleCount,
                   int signalCount)
{
   return
         (
           "#define HL1Count "              + ( string )hl1NeuronCount + "                     \r\n"
           "#define HL2Count "              + ( string )hl2NeuronCount + "                     \r\n"
           //------------------------------------------------------------------------------------
           "#define NeuronSensitivity  "    + ( string )NeuronSensitivity_P + "                \r\n"
           //------------------------------------------------------------------------------------
           "#define sampleCount "           + ( string )sampleCount + "                        \r\n"
           //------------------------------------------------------------------------------------
           "#define signalCount "           + ( string )signalCount + "                        \r\n"
           //------------------------------------------------------------------------------------
           "#define StrArrSaSize "          + ( string )( sizeof (ArrSample) / sizeof ( float )) + "\r\n"
           "typedef struct{float C[StrArrSaSize];} ArrSa;                                   \r\n"
           //------------------------------------------------------------------------------------
           "#define StrArrWeSize "          + ( string )( sizeof (ArrWe) / sizeof ( float )) + "    \r\n"
           "typedef struct{float C[StrArrWeSize];} ArrWe;                                   \r\n"
           //------------------------------------------------------------------------------------
           "#define StrArrCrSize "          + ( string )( sizeof (ArrCr) / sizeof ( float )) + "    \r\n"
           "typedef struct{float C[StrArrCrSize];}ArrCr;                                    \r\n"
           //------------------------------------------------------------------------------------
           "#define Spread "                + ( string )(Spread_P * Point ()) + "               \r\n"
           //------------------------------------------------------------------------------------
           "#define Point "                 + ( string ) Point () + "                            \r\n"
           "#define SL "                    + ( string )(StopLoss_P * Point ()) + "             \r\n"
           "#define TP "                    + ( string )(TakeProfit_P * Point ()) + "           \r\n"
           //------------------------------------------------------------------------------------
           "                                                                                \r\n"
           "__kernel void Work(__global ArrSa *Sample,                                      \r\n"
           "                   __global ArrWe *Weights,                                     \r\n"
           "                   __global ArrCr *Result)                                      \r\n"
           "{                                                                               \r\n"
           "  int thread       = get_global_id(0);                                          \r\n"
           "                                                                                \r\n"
           "  //------------------Переменные нейронной сети---------------------------------\r\n"
           "  float nHL1 [HL1Count];   // Нейроны первого скрытого слоя                     \r\n"
           "  float nHL2 [HL2Count];   // Нейроны второго скрытого слоя                     \r\n"
           "  ArrWe parametr = Weights[thread];  // Параметры системы                       \r\n"
           "  int   cnt_W    = 0;     // счетчик весов                                      \r\n"
           "  float out      = 0.0;   // выход сети                                         \r\n"
           "                                                                                \r\n"
           "  //-------------------Переменные для торговли----------------------------------\r\n"
           "  float temp             = 0.0;    // для временного хранения чего нибудь       \r\n"
           "                                                                                \r\n"
           "  //---параметры цены                                                           \r\n"
           "  float priceASK            = 0.0;   // текущая Ask цена                        \r\n"
           "  float priceBID            = 0.0;   // текущая Bid цена                        \r\n"
           "  float pricePrevHighASK    = 0.0;   // максимум предыдущей свечи Ask           \r\n"
           "  float pricePrevHighBID    = 0.0;   // максимум предыдущей свечи Bid           \r\n"
           "  float pricePrevLowASK     = 0.0;   // минимум предыдущей свечи Ask            \r\n"
           "  float pricePrevLowBID     = 0.0;   // минимум предыдущей свечи Bid            \r\n"
           "                                                                                \r\n"
           "  float posType             = 0.0;   // тип сделки:                             \r\n"
           "                                     // 1.0 - buy,                              \r\n"
           "                                     //-1.0 - sell;                             \r\n"
           "                                     // 0.0 - нет открытой сделки               \r\n"
           "  float posPriceClose       = 0.0;                                              \r\n"
           "  float posPriceClosePrevHi = 0.0;                                              \r\n"
           "  float posPriceClosePrevLo = 0.0;                                              \r\n"
           "                                                                                \r\n"
           "  //-----------------Текущие показатели позиции---------------------------------\r\n"
           "  float posPriceSL          = 0.0;    // цена StopLoss открытой сделки          \r\n"
           "  float posPriceTP          = 0.0;    // цена TakeProfit открытой сделки        \r\n"
           "                                                                                \r\n"
           "  //--------------------Статистика торговли-------------------------------------\r\n"
           "  int   StTradeProfitCount  = 0;      // кол-во приб. сделок                    \r\n"
           "  int   StTradeLossCount    = 0;      // кол-во уб. сделок                      \r\n"
           "                                                                                \r\n"
           "  int   StTradeLossSeries   = 0;     // текущая серия убыточных ордеров         \r\n"
           "  int   StTradeMaxLossSer   = 0;     // самая длинная серия уб.ордеров          \r\n"
           "                                                                                \r\n"
           "  //-----------------------Тут прогон по истории--------------------------------\r\n"
           "  for(int hist = 0;hist < sampleCount;hist++)                                   \r\n"
           "  {                                                                             \r\n"
           "    cnt_W = 0;                                                                  \r\n"
           "    //---------------Обработаем первый скрытый слой-----------------------------\r\n"
           "    //Добавим смещение точек насыщения нейрона: (+b)                            \r\n"
           "    for(int u = 0;u < HL1Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      nHL1[u] = parametr.C[cnt_W];                                              \r\n"
           "      cnt_W++;                                                                  \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
           "    //Сумма произведений нейронов предыдущего слоя и их весов:                  \r\n"
           "    // (+w1*x1+...+wn*xn) для каждого нейрона                                   \r\n"
           "    for(int u = 0;u < HL1Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      for(int i = 0;i < signalCount;i++)                                        \r\n"
           "      {                                                                         \r\n"
           "        nHL1[u] += Sample[hist].C[i + 3] * parametr.C[cnt_W];                   \r\n"
           "        cnt_W++;                                                                \r\n"
           "      }                                                                         \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
           "    //Посчитаем функцию активации для каждого скрытого нейрона                  \r\n"
           "    for(int u = 0;u < HL1Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      nHL1[u] = 5.0 * nHL1[u] / (1.0 + fabs(4.02 * nHL1[u]));                   \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
           "    //---------------Обработаем второй скрытый слой-----------------------------\r\n"
           "    //Добавим смещение точек насыщения нейрона: (+b)                            \r\n"
           "    for(int u = 0;u < HL2Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      nHL2[u] = parametr.C[cnt_W];                                              \r\n"
           "      cnt_W++;                                                                  \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
          
 

コードの継続:

          "    //Сумма произведений нейронов предыдущего слоя и их весов:                  \r\n"
           "    // (+w1*x1+...+wn*xn) для каждого нейрона                                   \r\n"
           "    for(int u = 0;u < HL2Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      for(int i = 0;i < HL1Count;i++)                                           \r\n"
           "      {                                                                         \r\n"
           "        nHL2[u] += nHL1[i] * parametr.C[cnt_W];                                 \r\n"
           "        cnt_W++;                                                                \r\n"
           "      }                                                                         \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
           "    //Посчитаем функцию активации для каждого скрытого нейрона                  \r\n"
           "    for(int u = 0;u < HL2Count;u++)                                             \r\n"
           "    {                                                                           \r\n"
           "      nHL2[u] = 5.0 * nHL2[u] / (1.0 + fabs(4.02 * nHL2[u]));                   \r\n"
           "    }                                                                           \r\n"
           "                                                                                \r\n"
           "    //-----------------Обработаем выходной слой---------------------------------\r\n"
           "    //Добавим смещение точек насыщения нейрона: (+b)                            \r\n"
           "    out = parametr.C[cnt_W];                                                    \r\n"
           "    cnt_W++;                                                                    \r\n"
           "                                                                                \r\n"
           "    //Сумма произведений нейронов предыдущего слоя и их весов:                  \r\n"
           "    // (+w1*x1+...+wn*xn) для каждого нейрона                                   \r\n"
           "    for(int i = 0;i < HL2Count;i++)                                             \r\n"
           "    {                                                                           \r\n"
           "      out += nHL2[i] * parametr.C[cnt_W];                                       \r\n"
           "      cnt_W++;                                                                  \r\n"
           "    }                                                                           \r\n"
           "    //==========================================================================\r\n"
           "                                                                                \r\n"
           "                                                                                \r\n"
           "    //==========================================================================\r\n"
           "    priceASK         = Sample[hist].C[0] + Spread;                              \r\n"
           "    priceBID         = Sample[hist].C[0];                                       \r\n"
           "                                                                                \r\n"
           "    pricePrevHighASK = Sample[hist].C[1] + Spread;                              \r\n"
           "    pricePrevHighBID = Sample[hist].C[1];                                       \r\n"
           "                                                                                \r\n"
           "    pricePrevLowASK  = Sample[hist].C[2] + Spread;                              \r\n"
           "    pricePrevLowBID  = Sample[hist].C[2];                                       \r\n"
           "                                                                                \r\n"
           "    //-----------------проверка условий на выход из рынка-----------------------\r\n"
           "    // если есть открытая поза                                                  \r\n"
           "    if(posType != 0.0)                                                          \r\n"
           "    {                                                                           \r\n"
           "      if(posType == 1.0)                                                        \r\n"
           "      {                                                                         \r\n"
           "        posPriceClose       = priceBID;                                         \r\n"
           "        posPriceClosePrevHi = pricePrevHighBID;                                 \r\n"
           "        posPriceClosePrevLo = pricePrevLowBID;                                  \r\n"
           "      }                                                                         \r\n"
           "      else                                                                      \r\n"
           "      {                                                                         \r\n"
           "        posPriceClose       = priceASK;                                         \r\n"
           "        posPriceClosePrevHi = pricePrevHighASK;                                 \r\n"
           "        posPriceClosePrevLo = pricePrevLowASK;                                  \r\n"
           "      }                                                                         \r\n"
           "                                                                                \r\n"
           "                                                                                \r\n"
           "      // может уже сработал SL?                                                 \r\n"
           "      if(posType * (posPriceSL - posPriceClose) >= 0.0 ||                       \r\n"
           "         posType * (posPriceSL - posPriceClosePrevLo) >= 0.0)                   \r\n"
           "      {                                                                         \r\n"
           "        // на одну убыточную сделку больше                                      \r\n"
           "        StTradeLossCount++;                                                     \r\n"
           "        // текущая серия убыточных сделок увеличилась                           \r\n"
           "        StTradeLossSeries++;                                                    \r\n"
           "        // если серия уб. сделок больше чем в истори, то запомним               \r\n"
           "        StTradeMaxLossSer = (StTradeMaxLossSer < StTradeLossSeries) ?           \r\n"
           "                            StTradeLossSeries : StTradeMaxLossSer;              \r\n"
           "        // позиция закрыта                                                      \r\n"
           "        posType = 0.0;                                                          \r\n"
           "      }                                                                         \r\n"
           "      // нет, SL не сработал                                                    \r\n"
           "      else                                                                      \r\n"
           "      {                                                                         \r\n"
           "        // может уже сработал TP?                                               \r\n"
           "        if(posType * (posPriceClose - posPriceTP) >= 0.0 ||                     \r\n"
           "           posType * (posPriceClosePrevHi - posPriceTP) >= 0.0)                 \r\n"
           "        {                                                                       \r\n"
           "          // на одну прибыльную сделку больше                                   \r\n"
           "          StTradeProfitCount++;                                                 \r\n"
           "          // текущая серия убыточных сделок закончилась                         \r\n"
           "          StTradeLossSeries = 0;                                                \r\n"
           "          // позиция закрыта                                                    \r\n"
           "          posType = 0.0;                                                        \r\n"
           "        }                                                                       \r\n"
           "      }                                                                         \r\n"
           "                                                                                \r\n"
           "    }                                                                           \r\n"
           "    //--------------------------------------------------------------------------\r\n"
           "                                                                                \r\n"
           "                                                                                \r\n"
           "    //-----------------проверка сигнала на вход в рынок-------------------------\r\n"
           "    // если нет открытых поз проверим возможность открытия                      \r\n"
           "    if(posType == 0.0 && hist < (sampleCount - 1))                              \r\n"
           "    {                                                                           \r\n"
           "      // если есть сигнал на покупку                                            \r\n"
           "      if(NeuronSensitivity < out)                                               \r\n"
           "      {                                                                         \r\n"
           "        posPriceTP   = priceASK + TP;                                           \r\n"
           "        posPriceSL   = priceASK - SL;                                           \r\n"
           "        posType = 1.0;                                                          \r\n"
           "      }                                                                         \r\n"
           "      // если есть сигнал на продажу                                            \r\n"
           "      if(out < -NeuronSensitivity)                                              \r\n"
           "      {                                                                         \r\n"
           "        posPriceSL   = priceBID + SL;                                           \r\n"
           "        posPriceTP   = priceBID - TP;                                           \r\n"
           "        posType = -1.0;                                                         \r\n"
           "      }                                                                         \r\n"
           "    }                                                                           \r\n"
           "  }                                                                             \r\n"
           "                                                                                \r\n"
           "                                                                                \r\n"
           "  //----------------------------------------------------------------------------\r\n"
           "  float Profit = ((float)StTradeProfitCount*TP)-((float)StTradeLossCount*SL);   \r\n"
           "  Result[thread].C[0] =  Profit;                                                \r\n"
           "  Result[thread].C[1] = -StTradeMaxLossSer;                                     \r\n"
           "}                                                                               \r\n"
          );
}
//————————————————————————————————————————————————————————————————————————————————————————————————
 
Renat Fatkhullin:

MQL5コードのGPU計算だけでなく、ターミナルのグラフィカルな機能のデモも行っています。

スクリプトとしてのソースコード全文を添付します。OpenCL 1.2での不具合は修正されました。

これはカッコイイ!3Dグラフィックスを作るので、重宝しますよ。そして、メガプロジェクトにふさわしいスピードが出る。今日、試運転に伺います(笑)。
 
Andrey Dik:

の続きのコードです。

ところで、OCLにコードを送るのに、行単位ではなく、ファイルの形で何とか送ることはできないでしょうか?そうでないと、ちょっと不気味な感じがします。

 
Alexey Volchanskiy:

ところで、OCLにコードを送るのに、一行ごとのシートではなく、何らかの形でファイルとして送ることは可能でしょうか?ちょっと不気味な感じがします。

OCLコードは単なる文字列です。文字列変数にファイルを読み込んで、GPUに送ればいいのです。
 
私には効きません(
 

2016年末の現在、すでに対象システムにOpenCLが搭載されていることを主張することが可能になっていることは重要なポイントです。

GPUがない場合でも、OpenCLはCPU上で全コアを使って動作します。デバイスセットはこのような感じです。

OpenCL  Device #0: GPU Advanced Micro Devices, Inc. Hawaii with OpenCL 2.0 (44 units, 1080 MHz, 8192 Mb, version 2117.13 (VM), rating 1760)
OpenCL  Device #1: CPU GenuineIntel Intel(R) Xeon(R) CPU E5-2690 v3 @ 2.60 GHz with OpenCL 1.2 (24 units, 2598 MHz, 32680 Mb, version 2117.13 (sse2,avx), rating 85)

端末は性能評価に基づいて、最も高速なデバイスを自動的に選択します。また、CLContextCreate 機能により、手動で任意のデバイスを選択することも可能です。

残念ながら、Windows XPでのOpenCLのことは忘れてください。そして、32ビットOS全般......2017年という時代です。

さらに不愉快なのは、NvidiaがOpenCLの規格を実質的に妨害し、OpenCL 2.0を実装していない状況だ。最初はOpenCL 1.2の実装を妨害し、今度はOpenCL 2.0の実装を妨害したのです。CUDAの自社実装を推進するためにこのようなことをしており、コミュニティ全体に損害を与えています。

その上、Nvidiaは、数学での使用を制限し、専用カード(Tesla)の購入を刺激するために、ゲーマーカードの精度を意図的に低くしています。

このような背景から、AMDは明らかに高速な演算処理(AMDのマイニングファームは通常構築されている)だけでなく、オープンスタンダード戦略(非常に開放的でパブリックドメインに押し上げている)でも勝っているように見えます。AMDのカードにOpenCL 2.0が導入されたことで、この仕様はCUDAの能力に非常に近くなり、今ではCUDAの下地を作る意味が全くなくなってしまいました。

 
近々、少なくともCPU実装のMQL5 Cloud Networkで OpenCLを使えるようにする予定です。
Распределенные вычисления в сети MQL5 Cloud Network
Распределенные вычисления в сети MQL5 Cloud Network
  • cloud.mql5.com
Заработать деньги, продавая мощности своего компьютера для сети распределенных вычислений MQL5 Cloud Network