English
preview
Спектр Гильберта в MQL5: Визуализация рыночных циклов по времени, частоте и энергии в реальном времени

Спектр Гильберта в MQL5: Визуализация рыночных циклов по времени, частоте и энергии в реальном времени

MetaTrader 5 — Индикаторы |
31 0
Olamide Daniel Adebayo
Olamide Daniel Adebayo

Введение

Если внимательно присмотреться к практически любому ценовому графику, то, как правило, можно обнаружить, что в его основе лежит более одного цикла. На пятиминутном графике XAUUSD могут одновременно присутствовать быстрые колебания, характерные для скальпинга, более медленные внутридневные колебания и еще более медленный многодневный дрейф — все это накладывается друг на друга и выглядит как одна ломаная линия. Традиционные инструменты позволяют рассматривать лишь один временной масштаб за раз: скользящая средняя с коротким периодом показывает быстрые колебания, но скрывает медленные, а с длинным периодом — наоборот. А что, если бы вы могли видеть все циклы одновременно, отслеживать изменения их частот и энергии в реальном времени и уловить момент, когда рынок переходит от неровного, высокочастотного режима к плавному низкочастотному тренду?

Именно это и дает вам спектр Гильберта. Он основан на преобразовании Гильберта — Хуанга (HHT), которое состоит из двух частей: метода эмпирической модовой декомпозиции (EMD), разлагающего сигнал на несколько колебательных составляющих без задания фиксированных базисных функций, в отличие от анализа Фурье, и спектрального анализа Гильберта (HSA), который для каждой из этих составляющих определяет мгновенную частоту и энергию на каждом баре. Объединив эти значения в пределах скользящего окна, вы получите обновляемую в реальном времени поверхность "время–частота–энергия" — спектр Гильберта, отображаемый прямо на графике.

Область применения: в этой статье создается диагностический индикатор на MQL5, а не советник, генерирующий сигналы. Здесь отсутствует логика исполнения торговых операций. Цель — дать вам возможность прямо на графике в реальном времени видеть, какие циклы сейчас доминируют в динамике цены, и использовать эту информацию вместе с собственной логикой входа в рынок и выхода из него. Графики результатов тестирования на истории, такие как кривая баланса, намеренно не приводятся: вместо этого выполняется численная проверка на синтетическом сигнале с известным частотным составом и проверка отрисовки в реальном времени на графике XAUUSD M5.

Мы создадим этот индикатор на MQL5 с нуля. Конвейер обработки включает четыре части: алгоритм просеивания, лежащий в основе EMD; приближение дискретного преобразования Гильберта с помощью КИХ-фильтра с оконной функцией (в MQL5 нет встроенной функции получения аналитического сигнала на основе FFT); вычисление мгновенной частоты с помощью развертки фазы; модуль отрисовки тепловой карты на базе CCanvas, обновляющий ее в реальном времени по мере формирования новых баров. Ниже приведены и подробно разобраны все функции, выполняющие реальные операции в этом конвейере: от построения сплайновой огибающей до управления последовательностью вычислений при закрытии бара в функции OnCalculate(). Ничего не остается просто упомянутым без пояснений. Рекомендуемая категория в сообществе MQL5 для данной работы — "Индикаторы", поскольку конечным результатом является пользовательский индикатор со встроенным движком визуализации и без кода управления сделками.

Коротко о том, кому адресована статья: для понимания материала не требуется подготовка в области обработки сигналов, но нужно уверенно читать код работы с массивами на MQL5 и быть готовым разобраться с несколькими формулами. Прежде чем представить код, реализующий каждую формулу, мы объясним ее смысл и назначение. Если вы уже знакомы с EMD и преобразованием Гильберта — Хуанга по реализации на другом языке программирования, большая часть описанного покажется вам прямым переносом; если же вы никогда не сталкивались ни с тем, ни с другим, приведенный ниже раздел об алгоритме просеивания написан как самостоятельный материал.


Зачем нужен частотно-временной анализ и как связаны его составляющие

Анализ Фурье — это тот инструмент, к которому, как правило, в первую очередь обращаются, когда речь заходит о "частоте" в ценовом ряду. Проблема заключается в том, что преобразование Фурье описывает все окно с помощью заранее выбранного фиксированного набора синусоидальных и косинусоидальных волн, что навязывает финансовым данным допущение о стационарности — неявную предпосылку о том, что частотный состав не претерпевает существенных изменений в пределах окна. Рыночные циклы редко соответствуют этому допущению: рост цен на золото то ускоряется, то замедляется, колебания становятся резче вблизи новостных событий, а сама продолжительность доминирующего цикла меняется в течение торговой сессии. Метод эмпирической модовой декомпозиции использует иной подход: он полностью основан на данных и извлекает колебательные моды непосредственно из локальных максимумов и минимумов самого ряда, а не проецирует его на фиксированный базис, хотя такая адаптивность сопряжена со своими компромиссами (подробнее об этом — в разделе "Ограничения" ближе к концу статьи).

Полная схема обработки выглядит так: на вход поступает исходный ценовой ряд, EMD путем просеивания выделяет из него небольшое число собственных модовых функций (IMF), упорядоченных от самой быстрой к самой медленной; затем к каждой IMF применяется дискретное преобразование Гильберта для построения ее аналитического сигнала, по которому определяются мгновенная амплитуда и мгновенная частота на каждом баре. Эти тройки (время, частота, энергия) для каждой IMF распределяются по ячейкам двумерной матрицы и отображаются в виде тепловой карты, обновляемой в реальном времени.

Рис. 1. Четырехэтапная схема обработки: просеивание ценового ряда методом EMD, применение преобразования Гильберта на основе КИХ-фильтра к каждой полученной IMF, извлечение мгновенной частоты и амплитуды и, наконец, отображение тепловой карты H(t,ω) в реальном времени с помощью CCanvas.

Сразу стоит отметить одно архитектурное решение: инструмент намеренно реализован как диагностическое наложение на график, а не встроен в обработчик OnTick() стратегии. Просеивание — итерационная и вычислительно затратная процедура, поэтому в индикаторе по умолчанию действует пересчет только при закрытии бара (это можно настроить), а сам индикатор размещен в отдельном подокне графика, чтобы не мешать наблюдению за движением цены и работе с другими индикаторами.

Стоит рассмотреть и очевидную альтернативу: вейвлет-преобразования также дают частотно-временное представление, и разработчики MQL5 иногда используют их вместо EMD. Компромисс заключается в том, что вейвлет-разложение по-прежнему требует заранее выбрать материнский вейвлет и фиксированную диадическую шкалу масштабов, что косвенно возвращает допущение о виде базисных функций — пусть и более гибкое, чем в случае одной синусоиды. Именно благодаря своей адаптивности метод EMD является привлекательным для анализа ценовых данных с неизвестным, изменяющимся во времени количеством доминирующих циклов: он определяет количество и форму колебательных мод на основе самого ряда, а не на основе заранее выбранного вами семейства вейвлетов. Плата за это — итерационные вычисления при просеивании для каждого окна. Именно поэтому в данной реализации действует пересчет только при закрытии бара, а не пересчет на каждом тике.

На практике готовую панель читают так: следят за тем, не разделяется ли горизонтальная полоса на две. Это может означать, что ранее доминировавший цикл действительно распадается на более быстрые и более медленные составляющие, но может быть и просто результатом того, что по мере сдвига скользящего окна анализа EMD немного иначе распределяет одно и то же исходное движение по модам. Рассматривайте единичное разделение или слияние полос как повод присмотреться внимательнее, а не как подтвержденную смену рыночного режима. Вертикальное положение полосы указывает на продолжительность доминирующего в данный момент цикла, а ее цвет (согласно цветовой шкале энергии, о которой пойдет речь позже) показывает уровень энергии в данной ячейке относительно ячейки с максимальной энергией в текущем окне, а не долю этой ячейки в общей энергии окна. Ничто из этого не заменяет вашу собственную логику входа и выхода — это просто ориентир, на каком временном масштабе стоит сосредоточить внимание именно сейчас.


Метод эмпирической модовой декомпозиции: алгоритм просеивания

EMD основан на простой, почти механической идее. Рассмотрим ряд цен x(t). Найдем все локальные максимумы и соединим их гладкой интерполирующей кривой, чтобы получить верхнюю огибающую e max (t). Поступим аналогичным образом с локальными минимумами, чтобы получить нижнюю огибающую e min (t). Вычислим среднее значение двух огибающих, чтобы получить локальное среднее m(t) = (e max (t) + e min (t)) / 2, и вычтем его из ряда:

h(t) = x(t) - m(t)

Согласно формальному определению, функция h(t) считается собственной модовой функцией, если она удовлетворяет двум условиям: число экстремумов и число пересечений нуля различаются не более чем на единицу, а среднее значение ее верхней и нижней огибающих везде близко к нулю. Точная проверка обоих условий на каждой итерации требует больших вычислительных затрат и на практике выполняется редко; здесь она также не проводится. Эта реализация опирается на приведенную ниже проверку числа экстремумов (их может быть слишком мало для построения огибающей), а для приближенной проверки второго условия использует классический критерий остановки SD типа Коши из работы Хуанга и др. (1998). Он позволяет оценить достаточность сходимости по нормированному изменению между двумя последовательными итерациями просеивания k-1 и k:

SD = Σt [h(k-1)(t) - h(k)(t)]² / Σt h(k-1)(t)²

Просеивание прекращается, как только значение SD опускается ниже порога (в данной реализации — 0,25, что входит в диапазон 0,2–0,3, рекомендованный в исходной статье). После выделения IMF 1 ее вычитают из исходного ряда, получая остаток, к которому снова применяют весь цикл просеивания для выделения IMF 2, и так далее, пока сам остаток не станет практически монотонным (менее трех экстремумов) или не будет достигнуто максимальное число IMF. Для интерполяции огибающих используется естественный кубический сплайн, реализованный с нуля на MQL5: вторые производные сплайна вычисляются путем решения трехдиагональной системы методом прогонки, поскольку в MQL5 нет встроенной функции сплайновой интерполяции для неравномерно расположенных узлов. Ниже без сокращений приведен полный проход просеивания. Он находит экстремумы, проверяет, не возник ли вырожденный случай, когда в окне их слишком мало для построения огибающей, строит обе огибающие с помощью вспомогательной функции сплайновой интерполяции и вычитает их локальное среднее из входных данных.

SiftOnce

//+------------------------------------------------------------------+
//|      One sifting pass: upper/lower envelopes -> mean -> subtract |
//+------------------------------------------------------------------+
bool CEMD::SiftOnce(const double &h[],int count,double &next[],bool &degenerate)
  {
   int maxIdx[],minIdx[];
   FindExtrema(h,count,maxIdx,minIdx);
   degenerate=false;

   if(ArraySize(maxIdx)<HS_MIN_EXTREMA || ArraySize(minIdx)<HS_MIN_EXTREMA)
     {
      degenerate=true;
      ArrayResize(next,count);
      ArrayCopy(next,h);
      return(false);
     }

   double upper[],lower[];
   double maxVal[],minVal[];
   ArrayResize(maxVal,ArraySize(maxIdx));
   ArrayResize(minVal,ArraySize(minIdx));
   for(int i=0;i<ArraySize(maxIdx);i++) maxVal[i]=h[maxIdx[i]];
   for(int i=0;i<ArraySize(minIdx);i++) minVal[i]=h[minIdx[i]];

   SplineEnvelope(maxIdx,maxVal,ArraySize(maxIdx),count,upper);
   SplineEnvelope(minIdx,minVal,ArraySize(minIdx),count,lower);

   ArrayResize(next,count);
   for(int i=0;i<count;i++)
      next[i]=h[i]-0.5*(upper[i]+lower[i]);

   return(true);
  }

Проверка вырожденного случая в строках 10–16 важнее, чем кажется: без нее на участке с постоянной ценой или выраженным однонаправленным движением (когда максимумов или минимумов меньше HS_MIN_EXTREMA) процедура расчета сплайна пыталась бы выполнить интерполяцию почти без опорных точек. Именно такие граничные случаи приводят к тому, что работающий в реальном времени индикатор незаметно выдает некорректные результаты вместо явного сбоя. В этом случае функция просто передает входные данные без изменений и сообщает, что ничего не изменилось, чтобы внешний цикл мог завершить выполнение. Сами экстремумы находятся простым проходом с трехточечным сравнением — без интерполяции, лишь путем сравнения каждого отсчета с его непосредственными соседями:

FindExtrema

//+------------------------------------------------------------------+
//|   Find local maxima / minima indices (simple 3-point comparison) |
//+------------------------------------------------------------------+
void CEMD::FindExtrema(const double &series[],int count,int &maxIdx[],int &minIdx[])
  {
   ArrayResize(maxIdx,0);
   ArrayResize(minIdx,0);
   for(int i=1;i<count-1;i++)
     {
      if(series[i]>series[i-1] && series[i]>series[i+1])
        {
         int n=ArraySize(maxIdx);
         ArrayResize(maxIdx,n+1);
         maxIdx[n]=i;
        }
      else if(series[i]<series[i-1] && series[i]<series[i+1])
        {
         int n=ArraySize(minIdx);
         ArrayResize(minIdx,n+1);
         minIdx[n]=i;
        }
     }
  }

Однако прежде чем перейти к внешнему циклу, стоит завершить разбор самой функции SiftOnce(): именно вызов SplineEnvelope() в строке 8 строит верхнюю и нижнюю огибающие по найденным выше экстремумам. Эта функция вычисляет значения естественного кубического сплайна, проходящего через экстремумы, для каждой целочисленной позиции бара; до первого узла и после последнего значение сохраняется постоянным:

SplineEnvelope

//+------------------------------------------------------------------+
//|    Evaluate the natural cubic spline over every integer position |
//|        0..count-1, extrapolating flat beyond the first/last knot |
//+------------------------------------------------------------------+
void CEMD::SplineEnvelope(const int &x[],const double &y[],int n,int count,double &envelope[])
  {
   ArrayResize(envelope,count);
   if(n==0)
     {
      ArrayInitialize(envelope,0.0);
      return;
     }
   if(n==1)
     {
      for(int i=0;i<count;i++) envelope[i]=y[0];
      return;
     }
   double y2[];
   SplineSecondDerivatives(x,y,n,y2);

   int seg=0;
   for(int i=0;i<count;i++)
     {
      if(i<x[0]) { envelope[i]=y[0]; continue; }
      if(i>x[n-1]) { envelope[i]=y[n-1]; continue; }
      while(seg<n-2 && i>x[seg+1]) seg++;
      double x0=x[seg], x1=x[seg+1];
      double h=x1-x0;
      if(h<=0) { envelope[i]=y[seg]; continue; }
      double a=(x1-i)/h;
      double b=(i-x0)/h;
      envelope[i]=a*y[seg]+b*y[seg+1]+
                  ((a*a*a-a)*y2[seg]+(b*b*b-b)*y2[seg+1])*(h*h)/6.0;
     }
  }

Для вычисления значений сплайна необходимо знать вторые производные в каждом узле. Для произвольного набора неравномерно расположенных узлов их находят, решая трехдиагональную систему линейных уравнений. Здесь для этого используется метод прогонки, а не универсальный решатель, поскольку в MQL5 нет встроенных средств сплайн-интерполяции с неравномерно расположенными узлами, а прямое решение трехдиагональной системы не требует больших вычислительных затрат:

SplineSecondDerivatives

//+------------------------------------------------------------------+
//|     Thomas algorithm tri-diagonal solve for natural cubic spline |
//|second derivatives at the knot points (x are strictly increasing) |
//+------------------------------------------------------------------+
void CEMD::SplineSecondDerivatives(const int &x[],const double &y[],int n,double &y2[])
  {
   ArrayResize(y2,n);
   if(n<3)
     {
      ArrayInitialize(y2,0.0);
      return;
     }
   double u[];
   ArrayResize(u,n);
   y2[0]=0.0;
   u[0]=0.0;
   for(int i=1;i<n-1;i++)
     {
      double sig=(double)(x[i]-x[i-1])/(double)(x[i+1]-x[i-1]);
      double p=sig*y2[i-1]+2.0;
      y2[i]=(sig-1.0)/p;
      double d1=(y[i+1]-y[i])/(double)(x[i+1]-x[i]);
      double d2=(y[i]-y[i-1])/(double)(x[i]-x[i-1]);
      u[i]=(6.0*(d1-d2)/(double)(x[i+1]-x[i-1])-sig*u[i-1])/p;
     }
   y2[n-1]=0.0;
   for(int k=n-2;k>=0;k--)
      y2[k]=y2[k]*y2[k+1]+u[k];
  }

Этот внешний цикл реализован в методе Decompose(), который индикатор фактически вызывает один раз при каждой перерисовке. Он многократно передает текущий остаток в SiftOnce(), после каждого прохода проверяет критерий остановки SD по Коши и, как только мода стабилизируется, сохраняет ее как следующую IMF, вычитает из остатка и проверяет, достаточно ли в самом остатке экстремумов для продолжения:

Decompose

//+------------------------------------------------------------------+
//|    Full decomposition: repeatedly extract IMFs from the residual |
//|  until the residual is monotonic/degenerate or m_maxImfs reached |
//+------------------------------------------------------------------+
int CEMD::Decompose(const double &price[],int count,double &imfs[][HS_MAX_LOOKBACK],double &residual[])
  {
   if(count<8) return(-1);
   if(count>HS_MAX_LOOKBACK)
     {
      Print("CEMD::Decompose - count (",count,") exceeds HS_MAX_LOOKBACK (",HS_MAX_LOOKBACK,")");
      return(-1);
     }

   ArrayResize(residual,count);
   ArrayCopy(residual,price);

   int extracted=0;
   for(int k=0;k<m_maxImfs;k++)
     {
      double h[];
      ArrayResize(h,count);
      ArrayCopy(h,residual);

      bool degenerateExit=false;
      for(int iter=0;iter<HS_SIFT_MAX_ITER;iter++)
        {
         double next[];
         bool degenerate=false;
         bool ok=SiftOnce(h,count,next,degenerate);
         if(!ok || degenerate)
           {
            //--- too few extrema to keep sifting: what's left is residual/
            //--- trend, not an oscillatory mode. Do not store it as an IMF.
            degenerateExit=true;
            break;
           }
         double sd=SDCriterion(h,next,count);
         ArrayCopy(h,next);
         if(sd<HS_SIFT_SD_THRESH)
            break;
        }

      //--- a degenerate stop means this k has no valid mode to contribute:
      //--- stop extracting altogether and leave the remainder in residual
      //--- rather than mislabeling a trend segment as an IMF
      if(degenerateExit)
         break;

      //--- store the extracted IMF (element-by-element: MQL5 does not support
      //--- row-slicing a fixed-second-dimension 2D array via ArrayCopy)
      for(int i=0;i<count;i++)
         imfs[k][i]=h[i];
      extracted++;

      //--- update residual
      for(int i=0;i<count;i++)
         residual[i]=residual[i]-h[i];

      //--- check if residual itself has too few extrema left -> stop extracting further IMFs
      int rMax[],rMin[];
      FindExtrema(residual,count,rMax,rMin);
      if(ArraySize(rMax)<HS_MIN_EXTREMA || ArraySize(rMin)<HS_MIN_EXTREMA)
         break;
     }

   return(extracted);
  }

Проверка критерия остановки SD по Коши в строке 37 напрямую реализует приведенную ранее формулу: нужно просуммировать квадраты разностей значений на двух последовательных итерациях просеивания, разделить результат на сумму квадратов значений предыдущей итерации и сравнить с порогом:

SDCriterion

//+------------------------------------------------------------------+
//|    Cauchy-type SD stopping criterion between two sift iterations |
//+------------------------------------------------------------------+
double CEMD::SDCriterion(const double &prev[],const double &curr[],int count)
  {
   double num=0.0,den=0.0;
   for(int i=0;i<count;i++)
     {
      double diff=prev[i]-curr[i];
      num+=diff*diff;
      den+=prev[i]*prev[i];
     }
   if(den<=1e-12) return(0.0);
   return(num/den);
  }

Здесь важны два защитных ограничения. HS_MAX_LOOKBACK задает максимальный размер окна, которое может обработать Decompose(), поскольку для хранения IMF используется массив фиксированного размера, заданного на этапе компиляции (правила MQL5 для многомерных массивов требуют, чтобы размер последнего измерения был константой). Если передать окно большего размера, оно будет сразу отклонено, а не молча усечено. Кроме того, HS_SIFT_MAX_ITER ограничивает число итераций внутреннего цикла просеивания для каждой IMF, поэтому даже обработка проблемного окна, для которого пороговое условие SD так и не выполняется, гарантированно завершается, не вызывая зависания графика.

На синтетическом сигнале, составленном из двух известных синусоид с добавлением медленного дрейфа и небольшого количества шума, этот цикл просеивания четко выделяет исходные составляющие. Быстрый цикл с периодом 8 баров попадает в IMF1, цикл с периодом 34 бара — в IMF2, а медленный дрейф входит в остаток — именно такой порядок и должен давать EMD: сначала самые быстрые колебания.

Рис. 2. Результат просеивания синтетического сигнала: исходный ряд, IMF1 (быстрый цикл с периодом 8 баров), IMF2 (цикл с периодом 34 бара), IMF3 (составляющая, близкая к тренду) и остаток. Каждая мода выделяет колебания отдельного масштаба.


От IMF к аналитическому сигналу: дискретное преобразование Гильберта

Сама по себе IMF — это лишь колеблющийся числовой ряд: она не дает напрямую ни частоты, ни значения энергии. Чтобы получить их, нужно построить аналитический сигнал z(t) = x(t) + i·y(t), где y(t) — преобразование Гильберта сигнала x(t). Ядро идеального непрерывного преобразования Гильберта имеет вид 1/(πt); его дискретный эквивалент задается формулой h[n] = 2/(πn) для нечетных n и равен нулю для четных n (включая n=0). Это ядро имеет бесконечный носитель, поэтому на практике его усекают до конечного числа отводов и применяют оконную функцию, чтобы найти компромисс между пульсациями в полосе пропускания и шириной переходной полосы. В данной реализации используется ядро с 65 отводами и окном Хэмминга, которое строится один раз в BuildKernel() и затем используется для каждой IMF:

BuildKernel

// Windowed-ideal-response FIR Hilbert kernel (odd taps only, Hamming-windowed)
void CHilbertTransform::BuildKernel(void)
  {
   ArrayResize(m_kernel,m_taps);
   int half=m_taps/2;
   for(int i=0;i<m_taps;i++)
     {
      int n=i-half;
      double ideal=0.0;
      if(n!=0 && n%2!=0)
         ideal=2.0/(M_PI*n);
      double w=0.54-0.46*MathCos(2.0*M_PI*i/(m_taps-1));
      m_kernel[i]=ideal*w;
     }
  }

Ядро строится один раз, а применяется к каждой IMF при каждой перерисовке. Функция Quadrature() выполняет непосредственную свертку входного ряда с этим ядром, без использования FFT: свертка с ядром из 65 отводов для окна длиной 200 баров требует настолько мало вычислений, что дополнительная сложность реализации через FFT здесь ничем не оправдана. Отсчеты за пределами окна с обеих сторон принимаются равными нулю; именно это допущение вызывает краевые переходные процессы, о которых пойдет речь ниже:

Quadrature

//+------------------------------------------------------------------+
//|                Direct-form convolution, zero-padded at the edges |
//+------------------------------------------------------------------+
void CHilbertTransform::Quadrature(const double &series[],int count,double &quad[])
  {
   ArrayResize(quad,count);
   int half=m_taps/2;
   for(int n=0;n<count;n++)
     {
      double acc=0.0;
      for(int k=0;k<m_taps;k++)
        {
         int idx=n-(k-half);
         if(idx>=0 && idx<count)
            acc+=m_kernel[k]*series[idx];
        }
      quad[n]=acc;
     }
  }

Получив в результате этой свертки квадратурную составляющую y(t), можно непосредственно вычислить мгновенную амплитуду и фазу:

a(t) = √(x(t)² + y(t)²)    φ(t) = atan2(y(t), x(t))

Эти две формулы реализованы в двух небольших методах, каждый из которых решает свою задачу. Методы намеренно оставлены раздельными, а не объединены в одну функцию, поскольку модулю построения спектра амплитуда и фаза нужны на разных этапах обработки:

InstantAmplitude

//+------------------------------------------------------------------+
//|              Instantaneous amplitude: a(n) = sqrt(x(n)^2+y(n)^2) |
//+------------------------------------------------------------------+
void CHilbertTransform::InstantAmplitude(const double &series[],const double &quad[],int count,double &amp[])
  {
   ArrayResize(amp,count);
   for(int i=0;i<count;i++)
      amp[i]=MathSqrt(series[i]*series[i]+quad[i]*quad[i]);
  }

InstantPhase

//+------------------------------------------------------------------+
//|         Instantaneous phase (wrapped, -pi..pi): atan2(y(n),x(n)) |
//+------------------------------------------------------------------+
void CHilbertTransform::InstantPhase(const double &series[],const double &quad[],int count,double &phase[])
  {
   ArrayResize(phase,count);
   for(int i=0;i<count;i++)
      phase[i]=MathArctan2(quad[i],series[i]);
  }

Сама по себе фаза ограничена интервалом (-π, π], что приводит к появлению пилообразных скачков при каждом пересечении границы. Перед дифференцированием для получения частоты необходимо выполнить развертку фазы: обнаружить между соседними отсчетами скачки, по модулю превышающие π, и прибавить или вычесть величины, кратные 2π, чтобы обеспечить непрерывность фазы:

UnwrapPhase

// Standard phase-unwrap: remove 2*pi jumps between consecutive samples
void CHilbertTransform::UnwrapPhase(double &phase[],int count)
  {
   double cumulative=0.0;
   for(int i=1;i<count;i++)
     {
      double delta=phase[i]-phase[i-1];
      if(delta>M_PI) cumulative-=2.0*M_PI;
      else if(delta<-M_PI) cumulative+=2.0*M_PI;
      phase[i]+=cumulative;
     }
  }

После развертки фазы, обеспечивающей ее непрерывность, мгновенную частоту в циклах на бар вычисляют с помощью центрально-разностной аппроксимации производной, умноженной на 1/(2π). Затем частоту ограничивают диапазоном [0; 0,5], допустимым по пределу Найквиста для корректно выделенной моды. Отрицательное значение частоты или значение выше предела Найквиста обычно является численным артефактом, а не реальным колебанием. Однако если частоту моды приходится ограничивать многократно, это также стоит рассматривать как признак того, что IMF выделена недостаточно хорошо (смешение мод, о котором пойдет речь далее), а не считать, что одно лишь ограничение частоты решило проблему. Поэтому для отображения значение ограничивают снизу и сверху, а не выводят как есть:

InstantFrequency

//+------------------------------------------------------------------+
//|    Instantaneous frequency: central-difference derivative of the |
//|    unwrapped phase, clipped to [0, 0.5] cycles/bar (Nyquist) and |
//|     floored at 0 since IMF instantaneous frequency should not go |
//|                                negative for a well-behaved mode. |
//+------------------------------------------------------------------+
void CHilbertTransform::InstantFrequency(const double &unwrappedPhase[],int count,double &freq[])
  {
   ArrayResize(freq,count);
   if(count<2) { ArrayInitialize(freq,0.0); return; }

   freq[0]=(unwrappedPhase[1]-unwrappedPhase[0])/(2.0*M_PI);
   for(int i=1;i<count-1;i++)
      freq[i]=(unwrappedPhase[i+1]-unwrappedPhase[i-1])/(2.0*(2.0*M_PI));
   freq[count-1]=(unwrappedPhase[count-1]-unwrappedPhase[count-2])/(2.0*M_PI);

   for(int i=0;i<count;i++)
     {
      if(freq[i]<0.0) freq[i]=0.0;
      if(freq[i]>0.5) freq[i]=0.5;
     }
  }

Следует уточнить один момент: вся эта цепочка — от Quadrature() до InstantFrequency() — выполняется один раз для каждой IMF при каждой перерисовке, а не один раз для всего ценового ряда. Для каждой IMF вычисляются собственный аналитический сигнал и собственная траектория мгновенной частоты. Именно это позволяет затем отобразить на спектре два или три одновременно действующих цикла, а не сводить все к одному смешанному значению частоты, как при наивном однопроходном применении преобразования Гильберта к исходному ценовому ряду.


Построение спектра Гильберта в реальном времени и его визуализация

Когда мгновенная частота и амплитуда известны для каждого бара каждой IMF, построение самого спектра сводится к распределению данных по частотным интервалам. Разделите ось частот от 0 до предела Найквиста (0,5 цикла на бар) на фиксированное число интервалов — в этой реализации их 40. Затем для каждого бара в скользящем окне анализа добавьте мгновенную энергию каждой IMF (квадрат амплитуды) в тот частотный интервал, в который попадает ее мгновенная частота на этом баре. Проделав это для всех IMF, получим матрицу H(t, ω): столбцы соответствуют времени, строки — частотным интервалам, а значение в каждой ячейке — накопленной энергии. Эта матрица и есть дискретизированный спектр Гильберта. Она формируется в функции BuildSpectrum(), которая перебирает все выделенные IMF, для каждой выполняет описанную в предыдущем разделе цепочку вычислений квадратурной составляющей, амплитуды и фазы, развертки фазы и вычисления частоты, а затем накапливает квадрат амплитуды в том частотном интервале, в который попадает ее мгновенная частота:

BuildSpectrum

//+------------------------------------------------------------------+
//|           Build the H(t,ω) energy matrix from all extracted IMFs |
//+------------------------------------------------------------------+
void BuildSpectrum(int imfCount,int count)
  {
   //--- clear
   for(int t=0;t<count;t++)
      for(int f=0;f<HS_FREQ_BINS;f++)
         g_H[t][f]=0.0;

   double imfRow[],quad[],amp[],phase[],unwrapped[],freq[];
   ArrayResize(imfRow,count);

   for(int k=0;k<imfCount;k++)
     {
      for(int i=0;i<count;i++)
         imfRow[i]=g_imfs[k][i];

      g_hilbert.Quadrature(imfRow,count,quad);
      g_hilbert.InstantAmplitude(imfRow,quad,count,amp);
      g_hilbert.InstantPhase(imfRow,quad,count,phase);

      ArrayResize(unwrapped,count);
      ArrayCopy(unwrapped,phase);
      g_hilbert.UnwrapPhase(unwrapped,count);
      g_hilbert.InstantFrequency(unwrapped,count,freq);

      for(int t=0;t<count;t++)
        {
         int bin=(int)MathFloor(freq[t]/0.5*HS_FREQ_BINS);
         if(bin<0) bin=0;
         if(bin>=HS_FREQ_BINS) bin=HS_FREQ_BINS-1;
         g_H[t][bin]+=amp[t]*amp[t];   // energy = amplitude^2
        }
     }
  }

Индекс частотного интервала в строке 30 — MathFloor(freq[t]/0.5*HS_FREQ_BINS) — полностью определяет правило распределения по интервалам: оно линейно отображает ограниченный диапазон частот [0; 0,5] на диапазон индексов [0; HS_FREQ_BINS-1], а две следующие сразу за ним проверки границ обрабатывают пограничные случаи вычислений с плавающей точкой, когда значение оказывается в точности равным 0,5 или чуть меньше нуля.

За отображение в реальном времени отвечает небольшой класс-обертка для CCanvas, который управляет графическим объектом "Растровая метка". Метод Init() создает эту метку один раз при запуске, привязывает ее к отдельному подокну индикатора на графике и заливает черным цветом. CCanvas рисует во внеэкранном растровом изображении формата ARGB, поэтому каждый вызов отрисовки начинается с заранее заданного фона, а не с пикселей, оставшихся от предыдущего изображения:

Init

//+------------------------------------------------------------------+
//| Create the bitmap-label canvas object and anchor it to the chart |
//|                                                        subwindow |
//+------------------------------------------------------------------+
bool CSpectrumCanvas::Init(long chartId,int subwindow,const string objName,
                            int width,int height,int freqBins=HS_FREQ_BINS)
  {
   m_chartId=chartId;
   m_subwindow=subwindow;
   m_objName=objName;
   m_width=width;
   m_height=height;
   m_freqBins=freqBins;

   if(!m_canvas.CreateBitmapLabel(m_chartId,m_subwindow,m_objName,20,20,m_width,m_height,COLOR_FORMAT_ARGB_NORMALIZE))
     {
      Print("CSpectrumCanvas: CreateBitmapLabel failed, error ",GetLastError());
      m_ready=false;
      return(false);
     }

   ObjectSetInteger(m_chartId,m_objName,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(m_chartId,m_objName,OBJPROP_XDISTANCE,20);
   ObjectSetInteger(m_chartId,m_objName,OBJPROP_YDISTANCE,20);
   ObjectSetInteger(m_chartId,m_objName,OBJPROP_BACK,false);
   ObjectSetInteger(m_chartId,m_objName,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(m_chartId,m_objName,OBJPROP_HIDDEN,true);

   m_canvas.Erase(ColorToARGB(clrBlack,255));
   m_canvas.Update();
   m_ready=true;
   return(true);
  }

При каждой перерисовке метод Draw() нормирует энергию текущего окна с помощью логарифмического преобразования (исходные значения квадрата амплитуды охватывают несколько порядков величины, а логарифмическая шкала сохраняет видимость деталей с низкой энергией, не давая всему изображению стать черным за исключением одного яркого пикселя), преобразует нормированную энергию в цвет по цветовой шкале "синий — голубой — желтый — красный" с помощью EnergyToColor() и закрашивает по одному прямоугольнику для каждой ячейки (время, частота):

EnergyToColor

//+------------------------------------------------------------------+
//|Blue (cold/low energy) -> cyan -> yellow -> red (hot/high energy) |
//+------------------------------------------------------------------+
uint CSpectrumCanvas::EnergyToColor(double normalized)
  {
   if(normalized<0.0) normalized=0.0;
   if(normalized>1.0) normalized=1.0;

   int r,g,b;
   if(normalized<0.33)
     {
      double t=normalized/0.33;
      r=0; g=(int)(t*255); b=255;
     }
   else if(normalized<0.66)
     {
      double t=(normalized-0.33)/0.33;
      r=(int)(t*255); g=255; b=(int)(255*(1.0-t));
     }
   else
     {
      double t=(normalized-0.66)/0.34;
      r=255; g=(int)(255*(1.0-t)); b=0;
     }
   return(ColorToARGB((color)((r<<16)|(g<<8)|b),255));
  }

Draw

//+------------------------------------------------------------------+
//| Draw the H(t,ω) matrix as a heatmap. Rows are drawn bottom-up so |
//| low frequency sits at the bottom of the panel, high frequency at |
//|                  the top (conventional spectrogram orientation). |
//+------------------------------------------------------------------+
bool CSpectrumCanvas::Draw(const double &H[][HS_FREQ_BINS],int timeCols)
  {
   if(!m_ready) return(false);
   if(HS_FREQ_BINS!=m_freqBins)
     {
      Print("CSpectrumCanvas: FEATURE CONTRACT VIOLATION - HS_FREQ_BINS (",HS_FREQ_BINS,
            ") does not match configured m_freqBins (",m_freqBins,"). Aborting draw.");
      return(false);
     }

   //--- find max energy in the current window for normalization (log-scaled)
   double maxE=0.0;
   for(int t=0;t<timeCols;t++)
      for(int f=0;f<m_freqBins;f++)
         if(H[t][f]>maxE) maxE=H[t][f];

   double logMax=MathLog(1.0+maxE);
   if(logMax<=1e-12) logMax=1.0;

   int colW=MathMax(1,m_width/MathMax(1,timeCols));
   int rowH=MathMax(1,m_height/m_freqBins);

   m_canvas.Erase(ColorToARGB(clrBlack,255));

   for(int t=0;t<timeCols;t++)
     {
      for(int f=0;f<m_freqBins;f++)
        {
         double e=H[t][f];
         double norm=MathLog(1.0+e)/logMax;
         uint clr=EnergyToColor(norm);

         int x0=t*colW;
         int y0=m_height-(f+1)*rowH;   // low freq at bottom
         m_canvas.FillRectangle(x0,y0,x0+colW-1,y0+rowH-1,clr);
        }
     }

   m_canvas.Update();
   return(true);
  }

Выражение y0=m_height-(f+1)*rowH в строке 39 обеспечивает панели стандартную ориентацию спектрограммы: частотные интервалы отображаются снизу вверх, так что низкие частоты располагаются внизу, а высокие — вверху — именно такую схему расположения сразу узнает любой, кто когда-либо видел аудиоспектрограмму. Панель размещается в отдельном подокне графика, определяемом с помощью ChartWindowFind(), и закрепляется с помощью CreateBitmapLabel, поэтому она находится под ценовым графиком, не нарушая его существующую компоновку.


Согласованность параметров и граничные случаи

Чтобы этот конвейер работал корректно, должны совпадать три значения: число частотных интервалов, заданное на этапе компиляции (HS_FREQ_BINS в SpectrumCanvas.mqh), значение входного параметра, доступного пользователю в настройках индикатора (InpFreqBins), и фиксированный размер последнего измерения самой матрицы H(t,ω). MQL5 требует, чтобы размер последнего измерения многомерного массива, передаваемого как параметр, был константой времени компиляции, поэтому число частотных интервалов нельзя произвольно менять входным параметром во время выполнения без перекомпиляции. В OnInit() сосредоточены все задачи инициализации самого индикатора: функция проверяет согласованность этих трех значений и при несоответствии явно сообщает об ошибке, возвращая INIT_PARAMETERS_INCORRECT, вместо того чтобы молча рисовать тепловую карту с искаженной частотной осью; приводит входные параметры максимального числа IMF и глубины окна анализа к допустимым диапазонам, задает размеры рабочих массивов и инициализирует холст:

OnInit

//+------------------------------------------------------------------+
//|                         Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit(void)
  {
   SetIndexBuffer(0,DummyBuffer,INDICATOR_DATA);
   ArraySetAsSeries(DummyBuffer,false);

   //--- FEATURE CONTRACT CHECK (three-way): the compile-time HS_FREQ_BINS
   //--- constant (SpectrumCanvas.mqh), the user-facing InpFreqBins input,
   //--- and the fixed trailing dimension of g_H[][HS_FREQ_BINS] must all
   //--- agree. A mismatch here would silently misalign the frequency
   //--- axis of the heatmap, so we fail loudly instead.
   if(InpFreqBins!=HS_FREQ_BINS)
     {
      PrintFormat("HilbertSpectrum: FEATURE CONTRACT VIOLATION - InpFreqBins (%d) != HS_FREQ_BINS (%d). "
                  "The frequency-bin count is fixed at compile time; adjust HS_FREQ_BINS in "
                  "SpectrumCanvas.mqh and recompile if you need a different resolution.",
                  InpFreqBins,HS_FREQ_BINS);
      return(INIT_PARAMETERS_INCORRECT);
     }

   g_effMaxImfs=InpMaxIMFs;
   if(g_effMaxImfs<1 || g_effMaxImfs>HS_MAX_IMFS)
     {
      PrintFormat("HilbertSpectrum: InpMaxIMFs (%d) out of range, clamping to HS_MAX_IMFS (%d).",
                  InpMaxIMFs,HS_MAX_IMFS);
      g_effMaxImfs=MathMax(1,MathMin(InpMaxIMFs,HS_MAX_IMFS));
     }

   g_effLookback=InpLookback;
   if(g_effLookback<32 || g_effLookback>HS_MAX_LOOKBACK)
     {
      PrintFormat("HilbertSpectrum: InpLookback (%d) out of range [32, %d], clamping.",
                  InpLookback,HS_MAX_LOOKBACK);
      g_effLookback=MathMax(32,MathMin(InpLookback,HS_MAX_LOOKBACK));
     }

   ArrayResize(g_imfs,g_effMaxImfs);
   ArrayResize(g_residual,g_effLookback);
   ArrayResize(g_H,g_effLookback);

   if(!g_canvas.Init(ChartID(),ChartWindowFind(),"HilbertSpectrumCanvas",800,InpCanvasHeight,HS_FREQ_BINS))
     {
      Print("HilbertSpectrum: canvas initialization failed.");
      return(INIT_FAILED);
     }

   g_contractOk=true;
   g_lastBarTime=0;

   IndicatorSetString(INDICATOR_SHORTNAME,"Hilbert Spectrum ("+IntegerToString(g_effMaxImfs)+" IMFs, "+
                       IntegerToString(g_effLookback)+" bars)");
   return(INIT_SUCCEEDED);
  }

Приведение значений InpMaxIMFs и InpLookback к допустимым диапазонам (строки 23–37) намеренно сделано мягким, в отличие от строгой проверки числа частотных интервалов: если предел числа IMF или глубина окна анализа выходят за допустимые границы, значение просто приводится к допустимому, а корректировка записывается в журнал. Небольшая ошибка в этих параметрах меняет лишь степень детализации изображения, тогда как несоответствие числа частотных интервалов незаметно исказило бы все показания на панели.

Прежде чем расширять возможности этого индикатора, стоит знать о нескольких других подводных камнях:

Просеивание может вырождаться в окнах с постоянными или почти монотонными данными. Если на участке ценового ряда меньше трех локальных экстремумов (сильный однонаправленный тренд почти без колебаний), для интерполяции огибающих недостаточно опорных точек. Реализация обнаруживает такую ситуацию и возвращает входные данные без изменений, вместо того чтобы выполнять деление при почти пустом наборе экстремумов.

Краевые переходные процессы КИХ-фильтра. Свертка конечного ряда с ядром на 65 отводов дает искаженные значения мгновенной частоты примерно на первых и последних 32 барах любого окна (половина числа отводов с каждой стороны), поскольку ядру нужны отсчеты с обеих сторон, а на краях их нет. Менее выраженные искажения, обусловленные переходной полосой, могут распространяться немного дальше вглубь окна. Исключайте как минимум это число баров из данных, используемых для принятия решений, и помните, что крайние левый и правый столбцы тепловой карты, обновляемой в реальном времени, всегда будут выглядеть более зашумленными, чем центральные.

Смешение мод. При классическом EMD одна IMF иногда может содержать колебания очень разных масштабов, а одно реальное колебание — разделяться между двумя IMF, особенно вблизи резких скачков цены. Это известное ограничение стандартного EMD (ансамблевая эмпирическая модовая декомпозиция решает эту проблему усреднением результатов просеивания сигнала с добавленным шумом, ценой пропорционального увеличения затрат процессорного времени). Его стоит учитывать, если вы планируете реализовать на этой основе вариант ансамблевой эмпирической модовой декомпозиции.

Основную долю затрат составляет просеивание. Наиболее ресурсоемкие этапы этого конвейера — построение огибающих с помощью кубических сплайнов и итеративный цикл просеивания, а не КИХ-свертка. Выполняйте пересчет только при закрытии бара (таково поведение по умолчанию), а не на каждом тике, и выбирайте минимальное скользящее окно анализа, достаточное для ваших задач: 200 баров — разумное значение по умолчанию для M5.

Что касается выбора параметров, порог критерия остановки SD задает компромисс между чистотой IMF и числом итераций просеивания: приблизьте его к 0,2 для более четкого разделения мод ценой большего числа итераций на окно или ослабьте требование, приблизив порог к 0,3, если нужна более быстрая перерисовка и допустимы чуть более зашумленные IMF. КИХ-ядро преобразования Гильберта с 65 отводами — компромиссный вариант: меньшее число отводов ускоряет перерисовку и сужает зону краевых переходных процессов (ее размер составляет примерно половину числа отводов), но снижает частотную избирательность ядра; большее число отводов улучшает частотную характеристику в полосе пропускания ценой расширения мертвой зоны на обоих концах каждого окна. Если вы сокращаете окно анализа до размера существенно меньше 200 баров, стоит соответственно сократить и длину ядра, иначе краевые переходные процессы займут непропорционально большую часть полезной области окна.


Объединяем все компоненты: внутри OnCalculate

Каждый из описанных выше компонентов — самостоятельный блок, но ни один из них не запускается сам по себе. OnCalculate() — вызываемая при поступлении тиков точка входа, которая объединяет эти блоки в индикатор, работающий в реальном времени. Последовательный разбор этой функции от начала до конца — самый прямой способ ответить на вопрос "как это работает": она определяет, нужен ли вообще пересчет, формирует ряд применяемой цены из исходных массивов OHLC, передает этот ряд в CEMD::Decompose(), направляет полученные IMF в BuildSpectrum() и, наконец, запрашивает перерисовку холста.

Первый шаг — вызов BuildSource(), которая формирует обычный массив double[] с рядом цен за последние count баров в соответствии с выбранным пользователем значением параметра применяемой цены. Эта функция нужна главным образом для того, чтобы вынести оператор выбора цены за пределы самой OnCalculate() и обеспечить правильный порядок элементов массива: по умолчанию в MQL5 для буферов индикаторов используется обычная индексация, а не индексация как в таймсерии, то есть от старых данных к новым; именно такой порядок требуется остальным этапам конвейера и аналогичной реализации на Python, используемой для проверки:

BuildSource

//+------------------------------------------------------------------+
//|      Extract the applied price series for the last `count` bars, |
//|oldest-first (chronological), matching OnCalculate's default non- |
//|                                    timeseries array orientation. |
//+------------------------------------------------------------------+
void BuildSource(const double &open[],const double &high[],const double &low[],const double &close[],
                  int rates_total,int count,double &dst[])
  {
   ArrayResize(dst,count);
   int start=rates_total-count;
   for(int i=0;i<count;i++)
     {
      int idx=start+i;
      switch(InpAppliedPrice)
        {
         case PRICE_OPEN:     dst[i]=open[idx]; break;
         case PRICE_HIGH:     dst[i]=high[idx]; break;
         case PRICE_LOW:      dst[i]=low[idx];  break;
         case PRICE_MEDIAN:   dst[i]=(high[idx]+low[idx])/2.0; break;
         case PRICE_TYPICAL:  dst[i]=(high[idx]+low[idx]+close[idx])/3.0; break;
         case PRICE_WEIGHTED: dst[i]=(high[idx]+low[idx]+2.0*close[idx])/4.0; break;
         default:              dst[i]=close[idx]; break;
        }
     }
  }

Получив исходный ряд, функция OnCalculate() объединяет все этапы в единую цепочку. Прежде всего выполняются две защитные проверки. Первая проверка служит для защиты от ситуации, когда массив close[] неожиданно переведен на индексацию как в таймсерии: параметры-массивы объявлены с модификатором const, поэтому функция не может сама изменить порядок индексации и при неверном порядке может лишь отказаться от выполнения, чтобы не допустить незаметного обращения по неправильным индексам. Вторая — расчет effTotal, который в режиме пересчета только при закрытии бара намеренно исключает из окна последний, еще формирующийся бар до передачи данных на последующие этапы. Благодаря этому просеивание выполняется только по полностью закрытым барам, а не по бару, который лишь вызвал срабатывание проверки появления "нового бара". Кроме того, ограничение пересчета до одного раза на бар в строках 34–35 обеспечивает достаточно низкую вычислительную нагрузку для непрерывной работы индикатора: просеивание — итеративный процесс, а решение сплайновой системы тоже требует ресурсов, поэтому пересчет на каждом входящем тике был бы напрасной работой ради значения, которое все равно будет перезаписано через несколько секунд, когда бар действительно закроется:

OnCalculate

//+------------------------------------------------------------------+
//|                              Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                 const int prev_calculated,
                 const datetime &time[],
                 const double &open[],
                 const double &high[],
                 const double &low[],
                 const double &close[],
                 const long &tick_volume[],
                 const long &volume[],
                 const int &spread[])
  {
   if(!g_contractOk) return(0);

   //--- defensive orientation check: this pipeline assumes oldest-first
   //--- (non-timeseries) indexing throughout, per the feature contract.
   //--- The price arrays are const, so we cannot force the flag here -
   //--- only refuse to run rather than silently misindex if it's wrong.
   if(ArrayGetAsSeries(close))
     {
      Print("HilbertSpectrum: close[] is unexpectedly series-indexed; refusing to compute.");
      return(rates_total);
     }

   //--- bar-close mode excludes the still-forming last bar from the
   //--- window, so the computation only ever sees fully closed bars
   int effTotal=(InpRecalcOnBarCloseOnly ? rates_total-1 : rates_total);
   if(effTotal<g_effLookback+8) return(rates_total);

   bool newBar=(time[rates_total-1]!=g_lastBarTime);

   if(InpRecalcOnBarCloseOnly && !newBar && prev_calculated>0)
      return(rates_total);

   g_lastBarTime=time[rates_total-1];

   int count=g_effLookback;
   double source[];
   BuildSource(open,high,low,close,effTotal,count,source);

   int imfCount=g_emd.Decompose(source,count,g_imfs,g_residual);
   if(imfCount<=0)
     {
      Print("HilbertSpectrum: EMD decomposition failed for this window, skipping redraw.");
      return(rates_total);
     }

   BuildSpectrum(imfCount,count);
   g_canvas.Draw(g_H,count);

   return(rates_total);
  }

Обратите внимание, что происходит при сбое декомпозиции в строке 44: вместо того чтобы рисовать устаревшую или частично вычисленную тепловую карту, функция выводит диагностическое сообщение и завершает работу, не изменяя холст и оставляя на экране последний успешно отрисованный кадр. Вырожденное окно (длинный, почти плоский участок ценового ряда со слишком малым числом экстремумов) вполне может время от времени встречаться в реальных рыночных данных, поэтому индикатор спроектирован так, чтобы безопасно обрабатывать такую ситуацию, не выводя сообщение об ошибке непосредственно на график.

У "сохранения последнего кадра на экране" есть и другие последствия: поскольку при каждой успешной перерисовке EMD заново выполняет расчет по всему скользящему окну, а не постепенно дополняет предыдущие результаты, значения в ранее отображенном историческом столбце могут измениться при следующей перерисовке, когда окно сместится и просеивание заново разложит этот участок ценового ряда в несколько ином контексте. Панель является "динамической" в том смысле, что она постоянно обновляется по мере закрытия новых баров, а не в том смысле, что столбец, однажды нарисованный, остается неизменным навсегда — о том, что это означает на практике, см. раздел "Ограничения" ниже.


Численная проверка и тестирование в тестере стратегий

Поскольку в индикаторе нет торговой логики, "тестирование" здесь подразумевает две разные проверки: проверку правильности вычислений на сигнале с известными истинными характеристиками и проверку корректности отрисовки в реальном времени при обновлении баров по поступающим тикам.

Для первой проверки вспомогательный скрипт на Python в точности воспроизводит алгоритм просеивания на MQL5 и КИХ-ядро преобразования Гильберта — с тем же критерием остановки, тем же числом отводов и той же оконной функцией. Скрипт запускается на синтетическом составном сигнале из двух синусоид с известными периодами (8 и 34 бара), медленного квадратичного дрейфа и небольшой добавки гауссова шума. Если конвейер обработки реализован правильно, EMD должен выделить колебания с этими двумя периодами в отдельные IMF, а преобразование Гильберта — точно определить их частоты:

verify_consistency.py

# verify_consistency.py - mirrors CEMD::Decompose exactly
imfs, residual = emd_decompose(signal)
for i, imf in enumerate(imfs):
    quad = hilbert_fir_quadrature(imf, kernel)
    freq = instantaneous_frequency(imf, quad)
    print(f"IMF{i+1}: median frequency ~= {np.median(freq):.4f} cycles/bar")

# Output:
# IMF1: median instantaneous frequency ~= 0.1250 cycles/bar (injected: 0.1250)
# IMF2: median instantaneous frequency ~= 0.0295 cycles/bar (injected: 0.0294)

После исключения баров, затронутых краевыми переходными процессами КИХ-фильтра, медиана частоты IMF2 отличается от заданного значения не более чем на треть процента, а медиана частоты IMF1 в точности совпадает с заданной частотой — это убедительно подтверждает, что цикл просеивания, сплайн огибающей, КИХ-ядро и цепочка развертки фазы и вычисления производной работают согласованно и правильно. Медиана здесь служит более показательной сводной статистикой: у более быстрого цикла IMF1 с периодом 8 баров на каждый цикл приходится меньше отсчетов для вычисления производной методом центральных разностей, поэтому оценки частоты от бара к бару заметно сильнее зашумлены, чем у IMF2, хотя в пределах окна обе оценки сходятся к правильным значениям.

Рис. 3. Восстановленные мгновенные частоты IMF1 и IMF2 (сплошные линии) в сравнении с известными заданными частотами (пунктирные линии) после исключения баров, затронутых краевыми переходными процессами КИХ-фильтра. Частота IMF2 почти точно совпадает с заданной на каждом баре. Частота IMF1 сильнее колеблется вокруг пунктирной линии, что согласуется с меньшей длиной ее цикла, хотя медиана по-прежнему совпадает с заданным значением.

Если пропустить тот же синтетический сигнал через весь конвейер обработки и сформировать матрицу H(t,ω), получится именно ожидаемая картина: две четкие, стабильные горизонтальные полосы энергии, по одной на каждой заданной частоте, без паразитной энергии, размазанной по остальной части частотной оси.

Рис. 4. Тепловая карта H(t,ω) для синтетического проверочного сигнала — такое же изображение панель CCanvas выводит на график в реальном времени. Две стабильные полосы энергии соответствуют двум заданным циклам.

Дополнительный диагностический показатель — маргинальный спектр Гильберта: энергия, проинтегрированная по всему временному окну для каждого частотного интервала, что сводит двумерную поверхность к одномерному профилю. Это полезный дополнительный показатель, когда нужно с одного взгляда увидеть, какие длины циклов преобладали в текущем окне анализа, вместо того чтобы следить за полной тепловой картой в режиме реального времени:

Рис. 5. Маргинальный спектр: суммарная энергия в каждом частотном интервале за проверочное окно; пики приходятся точно на две заданные частоты.

Сразу оговорим ограничения такой проверки: синтетический сигнал из двух синусоид с известными частотами позволяет в контролируемых условиях проверить правильность всей цепочки вычислений, но не гарантирует, что EMD столь же четко разделит циклы в реальном зашумленном движении цены XAUUSD, где число доминирующих циклов заранее неизвестно и может измениться внутри окна. Следует также прямо сказать, что verify_consistency.py — это намеренно выполненный построчный перенос логики MQL5, а не независимая эталонная реализация, поэтому совпадение результатов подтверждает лишь соответствие кода MQL5 его копии на Python, но не проверку какой-либо из этих реализаций по внешнему эталону.

Именно поэтому важна вторая, отдельная проверка: наблюдение за перерисовкой панели на реальных тиках в тестере стратегий. Синтетический тест проверяет правильность численных расчетов, а запуск на реальных данных подтверждает, что индикатор работает корректно при используемых на практике настройках ограничения пересчета и перерисовки, а также порядке индексации массивов, с которыми ему предстоит работать. В разделе "Ограничения", приведенном ниже, более подробно рассматривается, что ни одна из этих проверок на самом деле не доказывает.

Для второй проверки — отрисовки на реальных рыночных данных — запустите индикатор в визуальном режиме тестера стратегий на XAUUSD, M5 (или на выбранном вами символе и таймфрейме) и пошагово просматривайте тики, следя за тремя моментами: холст должен перерисовываться без искажений при каждом закрытии бара; ограничение пересчета до одного раза на бар должно действительно исключать лишние вычисления между закрытиями баров; задержка перерисовки должна оставаться заметно меньше длительности одного бара даже при полном окне анализа в 200 баров и максимальном числе IMF, равном шести. Если это не так, уменьшите окно анализа или максимальное число IMF, прежде чем полагаться на панель на малом таймфрейме.

Это качественная проверка отображения и быстродействия, а не тестирование прибыльности на исторических данных, поскольку здесь нет логики выставления ордеров, которую можно было бы оценивать. Если вам нужно точное значение задержки, такая проверка не заменит самостоятельного добавления в код средств измерения (см. раздел "Ограничения" ниже). Параметры для такого проверочного запуска:

Настройка
Значение
Символ / Таймфрейм
XAUUSD / M5
Применяемая цена
Цена закрытия
Скользящее окно анализа
200 баров
Максимальное число IMF
6
Частотные интервалы
40
Режим пересчета
Только при закрытии бара (с ограничением пересчета)

Учтите, что любые снимки графика, сделанные во время такого запуска на реальных данных, служат для визуальной, качественной проверки цепочки отрисовки, а не для оценки результатов торговли на истории. Прежде чем полагаться на поведение отображения для конкретного символа или торговой сессии, замените их свежими снимками из тестера стратегий, полученными на данных вашего брокера.


Ограничения и то, чего это не доказывает

Каждая из приведенных выше проверок подтверждает нечто более узкое, чем просто "этот индикатор работает". Прежде чем полагаться на панель в целях, выходящих за рамки визуального изучения, ознакомьтесь с тем, что именно было проверено, а что — нет.

Проверка на Python не является независимым эталоном. Скрипт verify_consistency.py намеренно построчно воспроизводит цикл просеивания, ядро КИХ-фильтра и цепочку операций развертки фазы из реализации на MQL5: это сделано специально, чтобы несоответствие между двумя реализациями проявлялось в виде численного расхождения. Совпадение результатов подтверждает, что код на MQL5 выполняет те же вычисления, что и его версия на Python, причем обе реализации основаны на одних и тех же формулах EMD и преобразования Гильберта из учебников; это не проверка по независимой эталонной реализации, и она не позволяет выявить ошибку, общую для обеих версий.

Синтетический тестовый сигнал специально сделан простым. Двух известных синусоид в сочетании с медленным дрейфом и гауссовым шумом достаточно, чтобы убедиться, что цепочка просеивания и КИХ-фильтрации восстанавливает ожидаемые частоты. Однако в сигнале нет разрывов, всплесков объема, внезапных периодов повышенной волатильности или резких асимметричных движений, которые часто приводят к смешению мод при EMD. Даже после прохождения этого теста конвейер обработки может менее четко разделять циклы на реальных данных сессии XAUUSD с частыми резкими колебаниями.

В статье нет количественной сравнительной оценки на реальных данных. Описанный в разделе "Тестирование" запуск на XAUUSD M5 — это визуальная, качественная проверка того, что панель правильно перерисовывается при обновлении баров по поступающим тикам в реальном времени, а не оценка точности разложения реальных цен. Известного "правильного" частотного разложения реальных рыночных данных, с которым можно было бы сравнить результат, нет; именно поэтому описанный выше тест на синтетическом сигнале служит отдельной контролируемой проверкой.

Инструментальные измерения задержки перерисовки не проводились. Фраза "Задержка перерисовки должна оставаться заметно меньше длительности одного бара" в разделе "Тестирование" — это ориентир, на что обращать внимание, а не результат измерения профилировщиком. Если вам нужны точные цифры для данных вашего брокера и вашего оборудования, вызовите GetMicrosecondCount() до и после выполнения тела функции OnCalculate() и запишите разницу в журнал — фактические значения будут зависеть от длины окна анализа, максимального числа IMF и характеристик оборудования.

Простой поиск экстремумов по трем точкам чувствителен к шуму и плато. Функция FindExtrema() отмечает точку как экстремум, только если ее значение строго больше (или меньше) значений обеих соседних точек. Поэтому плато из одинаковых значений или однотиковый шум в реальной точке разворота могут привести к появлению ложного экстремума или пропуску реального. Это напрямую влияет на качество просеивания, поскольку качество огибающей зависит от того, насколько верно определены экстремумы, по которым она построена.

Ограничение частоты диапазоном [0; 0,5] приводит к потере диагностической информации. Значение, принудительно приведенное к нижней или верхней границе диапазона, — как раз тот случай, который стоит отмечать отдельно. Как уже говорилось, если частота моды неоднократно подвергается ограничению, это часто указывает на плохое выделение моды (смешение мод), а не просто на численный шум. Однако текущая реализация молча ограничивает такие значения, не записывая эти случаи в журнал и никак их не отмечая.

Частотное разрешение низкое, а разбиение на интервалы — линейное. Сорок равных частотных интервалов в диапазоне [0; 0,5] цикла на бар дают ширину около 0,0125 цикла на бар для каждого интервала. Как показывают иллюстрации проверки, этого достаточно, чтобы четко разделить циклы с периодами 8 и 34 бара. Однако в низкочастотной части спектра та же ширина интервала охватывает гораздо больший диапазон периодов, чем в высокочастотной, поэтому два действительно разных медленных цикла могут попасть в один интервал, тогда как два быстрых окажутся в разных.

Столбцы тепловой карты для прошлых баров могут меняться по мере сдвига окна. Поскольку при каждой перерисовке EMD заново выполняет разложение по всему скользящему окну анализа, а не постепенно дополняет прежние результаты, значения в ранее показанном столбце могут немного измениться: с появлением новых баров в окне просеивание по-другому разлагает этот участок ценового ряда. Это закономерная особенность работы EMD со скользящим окном, а не ошибка, однако она означает, что историческая часть панели не остается неизменной после отрисовки — рассматривайте ее как обновляемую аналитическую поверхность, а не как неизменяемый журнал.

Обработка остатка — это проектное решение, а не жесткое правило. Когда просеивание прекращается (либо по критерию остановки SD, либо из-за недостаточного числа экстремумов), все, что осталось, включается в остаток, а не принудительно выделяется в еще одну IMF. Этот остаток в силу самого способа построения включает медленный тренд и ни на одном этапе обработки не анализируется на наличие циклических составляющих, поэтому действительно медленное колебание, которое так и не удается четко отделить от тренда, просто не появится на тепловой карте.

Искажения на концах сплайна возникают независимо от краевых переходных процессов КИХ-фильтра. SplineEnvelope() сохраняет постоянное значение огибающей до первого экстремума и после последнего вместо экстраполяции кривой; это отдельный источник краевых искажений, не связанный с дополнением сигнала нулями при свертке с КИХ-ядром. Он влияет на построение огибающей на каждой итерации просеивания, а не только на значения мгновенной частоты у самых границ итогового окна. Эти два эффекта накладываются друг на друга вблизи границ короткого окна анализа, а не заменяют друг друга, поэтому исключение только баров, затронутых краевыми переходными процессами КИХ-фильтра, не позволяет полностью устранить из первых IMF краевые артефакты, связанные со сплайнами.

"Доминирующий" означает "имеющий наибольшую энергию в текущем окне при текущем разбиении на частотные интервалы", а не утверждение о наличии устойчивого рыночного цикла. Когда в этой статье или на самой панели полоса называется "доминирующей", это сокращенное обозначение "полосы с наибольшей энергией в текущем скользящем окне анализа при текущем частотном разрешении", а не утверждение, что соответствующий временной масштаб объективно или неизменно представляет собой реальный цикл рынка. При другой длине окна анализа или на другом шаге его сдвига доминирующей вполне закономерно может оказаться другая полоса. Рассматривайте это как характеристику текущего окна, а не как обнаруженную константу.

Все это не повод отказываться от индикатора — это честное описание границ фактически выполненной проверки, позволяющее вам самостоятельно решить, какой вес придавать каждому отдельному показанию, прежде чем строить на его основе стратегию.


Заключение

Спектр Гильберта превращает расплывчатый вопрос "в каком цикле сейчас находится рынок", заставляющий переключаться между индикаторами, в обновляемую количественную поверхность, за которой можно наблюдать бар за баром. EMD выполняет сложную задачу поиска колебательных мод, не предполагая фиксированного базиса; преобразование Гильберта на основе КИХ-фильтра позволяет получить мгновенную частоту и энергию каждой моды, а простой этап распределения по частотным интервалам и сопоставления с цветовой шкалой превращает эти данные в тепловую карту, понятную с первого взгляда. Само по себе все это не предсказывает направление движения — это инструмент анализа, а не сигнал. Однако в сочетании с вашей собственной логикой входа в рынок инструмент дает принципиально иную информацию, чем скользящие средние или осцилляторы: какой временной масштаб действительно доминирует в движении цены в данный момент.

Если вы подбираете параметры для своего инструмента и таймфрейма, а не копируете настройки по умолчанию для XAUUSD M5, начните со скользящего окна анализа: оно должно с запасом охватывать несколько циклов самого медленного из интересующих вас колебаний, поскольку EMD требуется достаточное число повторений цикла в окне, чтобы четко отделить его от трендового остатка. После этого число отводов КИХ-фильтра и порог SD служат второстепенными параметрами настройки: приведенные здесь значения по умолчанию — разумная отправная точка для большинства внутридневных графиков валют и металлов, но на значительно меньших или больших таймфреймах может быть полезно уменьшить или увеличить длину ядра, как обсуждалось ранее.

Несколько естественных направлений дальнейшего развития: ансамблевая эмпирическая модовая декомпозиция для уменьшения смешения мод ценой большей нагрузки на процессор; адаптивное разбиение на частотные интервалы, расширяющиеся на низких частотах и сужающиеся на высоких; сопоставление мгновенной частоты доминирующей IMF со временем торговых сессий и выхода новостей, чтобы выяснить, группируются ли изменения длины цикла вокруг определенных рыночных событий. Весь приведенный здесь код точно соответствует проверочной реализации на Python, поэтому, расширяя реализацию на MQL5, одновременно расширяйте и реализацию на Python: именно эта согласованность позволила нам выявить проблемы численно еще до первой загрузки индикатора на график реального рынка.

Файл
Тип
Описание
HilbertSpectrum.mq5
Индикатор
Основной пользовательский индикатор: проверки согласованности параметров в OnInit, извлечение цен в BuildSource, пересчет только при закрытии бара в OnCalculate, отрисовка на холсте в реальном времени.
EMD.mqh
Подключаемый файл
Класс CEMD: алгоритм просеивания (SiftOnce), полный цикл разложения (Decompose), огибающие на основе кубических сплайнов, критерий остановки SD типа Коши.
HilbertTransform.mqh
Подключаемый файл
Класс CHilbertTransform: ядро преобразования Гильберта на основе КИХ-фильтра, свертка для получения квадратурной составляющей, мгновенная амплитуда, фаза и частота.
SpectrumCanvas.mqh
Подключаемый файл
Средство отрисовки тепловой карты на основе CCanvas с логарифмической цветовой шкалой энергии.
verify_consistency.py
Python
Автономная реализация, воспроизводящая цепочку EMD и КИХ-преобразования Гильберта для численной проверки на синтетических сигналах с известными частотами. Поставляется в составе архива в папке MQL5\Files\HilbertSpectrum\Python\.
MQL5.zip
Архив
Полный пакет с корневой папкой MQL5\, готовый к распаковке непосредственно в папку данных MQL5: Include\HilbertSpectrum\, Indicators\HilbertSpectrum\ и Files\HilbertSpectrum\Python\ для указанного выше скрипта проверки. В комплект не входят скомпилированные бинарные файлы .ex5 — перед запуском индикатора необходимо самостоятельно скомпилировать исходные файлы .mq5 в MetaEditor.

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/24084

Прикрепленные файлы |
MQL5.zip (14.45 KB)
Офлайн-обучение с подкреплением в MQL5: Обучение торговой политики по истории сделок без экспериментов на реальном рынке Офлайн-обучение с подкреплением в MQL5: Обучение торговой политики по истории сделок без экспериментов на реальном рынке
Создайте и разверните консервативную политику, обученную офлайн, используя только MQL5. Записанные сделки образуют фиксированный набор данных для двухслойной Q-сети, обучаемой методом консервативного Q-обучения, который снижает Q-значения действий с недостаточной поддержкой данными, чтобы ограничить ошибку экстраполяции. Советник загружает зафиксированные веса и применяет фильтр обнаружения состояний вне обучающего распределения, используя сохраненную статистику признаков. Это обеспечивает воспроизводимость обучения и исполнения без исследования среды в реальном времени.
Дробное преобразование Фурье: Индикатор цикла с адаптацией к скорости изменения частоты для MetaTrader 5 Дробное преобразование Фурье: Индикатор цикла с адаптацией к скорости изменения частоты для MetaTrader 5
В данной статье представлен реализованный непосредственно на MQL5 индикатор на основе дробного преобразования Фурье, предназначенный для определения того, ускоряется или замедляется доминирующий цикл. Он ищет поворот, обеспечивающий максимальную спектральную концентрацию в окне аналитического сигнала после удаления тренда, используя унитарное дробное преобразование Фурье (FrFT) на основе собственных векторов и поиск минимума энтропии методом золотого сечения, а затем восстанавливает линию цикла, ограниченную по полосе частот. Результаты проверки на чирп-сигналах с известными параметрами и на реальных ценах закрытия различных торговых инструментов и таймфреймов показывают, в каких случаях метод надежен, каково его систематическое смещение и насколько ограничена на практике получаемая с его помощью прогностическая информация.
Расстояние Вассерштейна для обнаружения дрейфа признаков в реальном времени на MQL5: Мониторинг входных данных модели ONNX методами оптимального транспорта Расстояние Вассерштейна для обнаружения дрейфа признаков в реальном времени на MQL5: Мониторинг входных данных модели ONNX методами оптимального транспорта
В этой статье реализован легковесный механизм защиты от дрейфа в пространстве признаков на MQL5 с использованием одномерного расстояния Вассерштейна-1: оценка методом сортировки и попарного сопоставления для окон одинакового размера, нормировка по межквартильному размаху (IQR) для каждого признака и фильтрация как по взвешенной сводной оценке, так и по максимальной статистике. Настройки задаются в манифесте JSON (размеры окон, веса, пороговые значения для предупреждений и критических состояний, действия). Детектор работает параллельно с классификатором ONNX; его работа проверяется в тестере стратегий, а результаты приводятся с явным указанием оговорок.
Архитектура машинного обучения для MetaTrader 5 (Часть 21): Анализ важности признаков Архитектура машинного обучения для MetaTrader 5 (Часть 21): Анализ важности признаков
Оценка важности признаков часто занижает вклад коррелированных предикторов, распределяя один сигнал между множеством сконструированных копий, тогда как несвязанные шумовые признаки могут оказаться выше в рейтинге. Мы измеряем этот эффект, сопоставляя результаты с заранее известной истинной картиной, и сравниваем четыре способа его устранения: перестановочную важность с перекрестной проверкой с очисткой, модели на основе одного признака, кластерный MDI и кластерный MDA. Результаты включают рейтинги для каждого метода и коэффициент размывания для каждого кластера, которые помогают выявить истинные сигналы и избежать удаления ценных признаков.