神经网络的顾问，分享经验。 - 页 9

新评论
 
Andrey Emelyanov:

早在2013年，我也曾试图实现一个类似的算法......但我用了7个指标，Zigzag被用来形成一个用于训练NS的矢量。但本质是一样的--我在寻找反向位置......当我开始使用Zigzag时，我不知道该用它做什么。直到我无意中发现了一些模式。这从根本上改变了我的TS。现在我的算法就简单多了。

1.在过去的一年里，在分钟和小时的时间框架内计算模式。

2.制作一个转折点的字典（对 "分钟模式-小时模式"）。

3.使用临界点词典教授NS（关于150-160对）。

这就是我的做法的结果。

对我的方法的缺点。

1) TS的高风险 - 由于不可能确定突破价格的确切值，TS放置9个带手数的挂单。1, 1, 3, 6, 14, 31, 70, 158, 355;

2) 难以实现退出算法（拖网TS）。

因此，NS可以用于交易，唯一的问题是如何教导NS...

P/s: 我所说的模式是指A.Merrill的模式（M & W）。

这是一个聪明的方法。而这些模式被简单地描述为矩阵中的柱状物的位置，没有考虑到实际的价格delta--只有相对位置？

我有一个想法，尝试模式指标，但用不同的框架--前5条我们分析后5条的指标，而用于趋势分析的两个指标--我们以10的增量进行分析，并考虑到绝对变化。

之字形是一个聪明的想法，但如何从平坦的晃动中过滤出峰值，有可能是趋势变化的虚假点？

 
-Aleks-:

一个明智的做法。而描述的模式只是矩阵中条形的位置，没有考虑到实际的价格delta--只是相对位置？

我有一个想法，尝试模式指标，但用不同的框架--前五条我们分析后五条的指标，还有两个指标用于趋势分析--我们以10为单位进行分析，同时考虑到绝对变化。

关于之字形是一个聪明的想法，但从平坦的晃动中筛选出来的峰值如何可能是趋势变化的假点？

我是这样做的。

有一个动态数组，专门存储模式对（我称它为字典），如果一对模式第二次进入字典，我就不把它写下来；还有两个计数器数组，分别是高级时间段和初级时间段--它们计算一个模式参与形成对的频率，即使它没有被写进字典。

训练向量是根据字典形成的，单个模式的权重= pattern_counter / maximum_counter。即，更经常参与成对的模式等于1，其他模式都小于1。这是你教完NS后得到的表格。

主要模式 主要计数 从属模式 从站计数 多层感知器总和
W2 18 W2 21 0.94914702
W14 14 W2 21 0.84972197
M15 20 M15 14 0.83269191
W1 11 W2 21 0.77499075
W13 10 W2 21 0.75006553
M15 20 M3 10 0.73813147
M15 20 M10 10 0.73812512
M15 20 M16 10 0.738099
W5 9 W2 21 0.72506739
W10 9 W2 21 0.72505412
M15 20 M11 9 0.71431236
W2 18 W1 11 0.71204136
W2 18 W5 11 0.7118911
W4 8 W2 21 0.70017271
W2 18 W4 10 0.68815217
W2 18 W7 10 0.68802818
M15 20 M7 7 0.66682395
M15 20 M14 6 0.64291215
W2 18 W13 8 0.64045346
M3 12 M15 14 0.63254238
W9 5 W2 21 0.62522345
W3 5 W2 21 0.62509623
W7 5 W2 21 0.62505511
M15 20 M12 5 0.61917222
M15 20 M8 5 0.6191331
W14 14 W1 11 0.61210667
W6 4 W2 21 0.60012943
W2 18 W14 6 0.59301682

NS的结构：64个输入神经元，4个内部，1个输出。也就是说，一个输入神经元描述一个模式。该网格的训练时间为40-50分钟，NS的误差不超过0.00001。

因此，我有一个模型，可以预测成对模式的意义，即使它以前不在字典里。

我已经在平坦和虚假的山峰上挣扎了很久，但我正在努力达到ZigZaga的计算水平。我稍微修改了标准Zigzag的代码，即在其基础上实现了ZZ百分比。到目前为止，代码看起来或多或少如下。

int MyCExtremum::GetCombiZigzag(const double    &high[],     // буфер цен high

                                const double    &low[],      // буфер цен low

                                const datetime  &time[],     // буфер время 

                                int             ExtDepth,    // глубина поиска экстремумов(первого прохода)

                                double          ExtDeviation,// "пороговое значение": жесткая ступенька + % роста цены

                                int             ExtBackstep  // глубина поиска экстремумов(второго прохода)

                               )

  {

   //--- value

   int    shift=0, whatlookfor=0, lasthighpos=0, lastlowpos=0, Deviat=1;

   double lasthigh=0.0, lastlow=0.0, percent=0.0;

   int    rates_total = ArraySize(time);          // размер входных таймсерий

   int    limit       = rates_total - ExtDepth;   // лимит на расчеты...

   //+---------------------------------------------------------------+

   //| ОЧЕНЬ ВАЖНАЯ ПРОВЕРКА ВЛИЯЮЩАЯ НА КОРРЕКТНОСТЬ ВЫЧИСЛЕНИЙ!    |

   //+---------------------------------------------------------------+

   if(ArrayIsSeries(high)) ArraySetAsSeries(high,false);

   if(ArrayIsSeries(low))  ArraySetAsSeries(low,false);

   if(ArrayIsSeries(time)) ArraySetAsSeries(time,false);

   //+---------------------------------------------------------------+

   //| ПРОВЕРКИ ВХОДНЫХ ПЕРЕМЕННЫХ                                   |

   //+---------------------------------------------------------------+

   if(rates_total<20)

     { 

      Print(__FUNCTION__," ERROR: the small size of the buffer.");

      return(-1);                                     

     }

   if(ExtDeviation<0 || ExtDeviation>100)

     { 

      Print(__FUNCTION__," ERROR: Is\'not correct a Deviation. The value of Deviation should be in the interval [0..100].");

      return(-1);                                     

     }

   //--- Проверка: Depth and Backstep

   if((ExtDepth < ExtBackstep)||(ExtDepth < 2))

     {

      Print(__FUNCTION__+" ERROR: Is\'not correct a Depth and Backstep. The value of Depth should be greater than Backstep.");

      return(-1);

     }

   //--- готовим буфер ZigzagBuffer[]

   if(ArraySize(ZigzagBuffer)>0) ArrayFree(ZigzagBuffer);               // Удаляем старые данные

   ArrayResize(ZigzagBuffer,rates_total, EXTREMUM_RESERVE);

   ArrayFill(ZigzagBuffer,0,rates_total,0.0);

   if(ArrayIsSeries(ZigzagBuffer))  ArraySetAsSeries(ZigzagBuffer,  false);

   //---

   if(ArraySize(HighMapBuffer)>0) ArrayFree(HighMapBuffer);             // Удаляем старые данные

   ArrayResize(HighMapBuffer,rates_total, EXTREMUM_RESERVE);

   ArrayFill(HighMapBuffer,0,rates_total,0.0);

   if(ArrayIsSeries(HighMapBuffer)) ArraySetAsSeries(HighMapBuffer, false);

   //---

   if(ArraySize(LowMapBuffer)>0) ArrayFree(LowMapBuffer);               // Удаляем старые данные

   ArrayResize(LowMapBuffer,rates_total, EXTREMUM_RESERVE);

   ArrayFill(LowMapBuffer,0,rates_total,0.0);

   if(ArrayIsSeries(LowMapBuffer))  ArraySetAsSeries(LowMapBuffer,  false);   

   //---

   if(ArraySize(TimeBuffer)>0) ArrayFree(TimeBuffer);                   // Удаляем старые данные

   ArrayResize(TimeBuffer,     rates_total, EXTREMUM_RESERVE);

   ArrayFill(TimeBuffer,    0, rates_total,   0);

   if(ArrayIsSeries(TimeBuffer))  ArraySetAsSeries(TimeBuffer,  false);   

   //--- корректировка Deviation

   if(ExtDeviation < 1)

     {

      Deviat = 1;

     }else

        {

         Deviat = (int)ExtDeviation;

        }

   //--- получаем "свежие" минимумы и максимумы

   if(GetHighMapZigzag(high,ExtDepth,Deviat,ExtBackstep) < 0) return(0);

   if(GetLowMapZigzag(low,ExtDepth,Deviat,ExtBackstep)   < 0) return(0);

   //--- final rejection

   for(shift=ExtDepth;shift<rates_total;shift++)

     {

      switch(whatlookfor)

        {

         case Start: // search for peak or lawn

            if(lastlow==0 && lasthigh==0)

              {

               if(HighMapBuffer[shift]!=0)

                 {

                  lasthigh=high[shift];

                  lasthighpos=shift;

                  whatlookfor=Sill;

                  ZigzagBuffer[shift]=lasthigh;

                  TimeBuffer[shift]=time[shift];

                 }

               if(LowMapBuffer[shift]!=0)

                 {

                  lastlow=low[shift];

                  lastlowpos=shift;

                  whatlookfor=Pike;

                  ZigzagBuffer[shift]=lastlow;

                  TimeBuffer[shift]=time[shift];

                 }

              }

            break;

         case Pike: // search for peak

            if(LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)

              {

               //---

               ZigzagBuffer[lastlowpos] = 0.0;

               TimeBuffer[lastlowpos]   = 0;

               //---

               lastlowpos=shift;

               lastlow=LowMapBuffer[shift];

               ZigzagBuffer[shift]=lastlow;

               TimeBuffer[shift]=time[shift];

               //--- Обязательно: покинуть switch

               break;

              }

            //--- Обход "двойственности"

            if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow)

              {

               //---

               ZigzagBuffer[lastlowpos] = 0.0;

               TimeBuffer[lastlowpos]   = 0;

               //---

               lastlowpos=shift;

               lastlow=LowMapBuffer[shift];

               ZigzagBuffer[shift]=lastlow;

               TimeBuffer[shift]=time[shift];

               //--- Обязательно: покинуть switch

               break;

              }

            if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)

              {

               //--- Проверка: % роста цены

               percent = (HighMapBuffer[shift]-lastlow)/(lastlow/100);

               if(percent > ExtDeviation)

                 {

                  lasthigh=HighMapBuffer[shift];

                  lasthighpos=shift;

                  ZigzagBuffer[shift]=lasthigh;

                  TimeBuffer[shift]=time[shift];

                  whatlookfor=Sill;

                 }

               percent = 0.0;

              }            

            break;

         case Sill: // search for lawn

            if(HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)

              {

               //--- 

               ZigzagBuffer[lasthighpos] = 0.0;

               TimeBuffer[lasthighpos]   = 0;

               //---

               lasthighpos=shift;

               lasthigh=HighMapBuffer[shift];

               ZigzagBuffer[shift]=lasthigh;

               TimeBuffer[shift]=time[shift];

               //--- Обязательно: покинуть switch

               break;

              }

            if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh)

              {

               //--- 

               ZigzagBuffer[lasthighpos] = 0.0;

               TimeBuffer[lasthighpos]   = 0;

               //---

               lasthighpos=shift;

               lasthigh=HighMapBuffer[shift];

               ZigzagBuffer[shift]=lasthigh;

               TimeBuffer[shift]=time[shift];

               //--- Обязательно: покинуть switch

               break;

              }

            if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)

              {

               //--- Проверка: % роста цены

               percent = (lasthigh-LowMapBuffer[shift])/(lasthigh/100);

               if(percent > ExtDeviation)

                 {

                  lastlow=LowMapBuffer[shift];

                  lastlowpos=shift;

                  ZigzagBuffer[shift]=lastlow;

                  TimeBuffer[shift]=time[shift];

                  whatlookfor=Pike;                  

                 }

               percent = 0.0;

              }

            break;

         default: 

            return(-1);

        }

     }

   //--- return value of prev_calculated for next call

   return(rates_total);   

  }

MyCExtremum是一个用于计算ZigZag...

附加的文件：
MyCExtremum.mqh  37 kb
 
-Aleks-:

一个明智的做法。而描述的模式只是矩阵中条形的位置，没有考虑到实际的价格delta--只是相对位置？

我有一个想法，尝试模式指标，但用不同的框架--前五条我们分析后五条的指标，还有两个指标用于趋势分析--我们以10为单位进行分析，同时考虑到绝对变化。

之字形是一个聪明的想法，但如何从平坦的晃动中过滤出峰值，有可能是趋势变化的虚假点？

关于利用模式分析指标--这非常有趣...我认为指标上的噪音较少，但我们应该选择指标，使一些指标抑制 "低噪音"，另一些指标抑制 "高噪音"，那么你就会得到一个多重过滤器。
 

Andrey Emelyanov:

NS的结构：64个输入神经元，4个内部，1个输出。也就是说，一个输入神经元描述一个模式。

你希望用这种模式取得成果吗？你的内层作为一个中间的压缩器，而不是作为一个分类器。
 
Andrey Emelyanov:

我做了以下工作。

有一个动态数组 专门存储模式对（我称之为字典），如果一对模式第二次进入字典，我就不把它写下来；还有两个数组高时限和低时限计数器--它们计算一个模式参与形成对的频率，即使它没有被写进字典。

训练向量是根据字典形成的，单个模式的权重= pattern_counter / maximum_counter。即，更经常参与成对的模式等于1，其他模式都小于1。这是你教完NS后得到的表格。

主要模式 主要计数 从属模式 从站计数 多层感知器总和
W2 18 W2 21 0.94914702
W14 14 W2 21 0.84972197
M15 20 M15 14 0.83269191
W1 11 W2 21 0.77499075
W13 10 W2 21 0.75006553
M15 20 M3 10 0.73813147
M15 20 M10 10 0.73812512
M15 20 M16 10 0.738099
W5 9 W2 21 0.72506739
W10 9 W2 21 0.72505412
M15 20 M11 9 0.71431236
W2 18 W1 11 0.71204136
W2 18 W5 11 0.7118911
W4 8 W2 21 0.70017271
W2 18 W4 10 0.68815217
W2 18 W7 10 0.68802818
M15 20 M7 7 0.66682395
M15 20 M14 6 0.64291215
W2 18 W13 8 0.64045346
M3 12 M15 14 0.63254238
W9 5 W2 21 0.62522345
W3 5 W2 21 0.62509623
W7 5 W2 21 0.62505511
M15 20 M12 5 0.61917222
M15 20 M8 5 0.6191331
W14 14 W1 11 0.61210667
W6 4 W2 21 0.60012943
W2 18 W14 6 0.59301682

NS的结构：64个输入神经元，4个内部，1个输出。也就是说，一个输入神经元描述一个模式。该网格的训练时间为40-50分钟，NS的误差不超过0.00001。

因此，我有一个模型，可以预测成对模式的意义，即使它以前不在字典里。

我已经在平坦和虚假的山峰上挣扎了很久，但我正在努力达到ZigZaga的计算水平。我稍微修改了标准Zigzag的代码，即在其基础上实现了ZZ百分比。到目前为止，代码看起来或多或少如下。

该阵列是一个有趣的解决方案。各对/各期之间的统计数字是否有差异，给出积极预测结果的模式的发生频率的稳定性一般如何？

关于之字形，我也有一个百分比的解决方案，但我也用更深的历史来计算之字形的参考部分，对照它来比较其他的百分比变化。

 
Andrey Emelyanov:
至于用模式分析指标--这非常有趣......我认为指标上的噪音较少，但你必须选择指标，以便一个抑制 "低噪音"，另一个抑制 "高噪音"，那么你就会得到一个多过滤器。
有许多不同的指标。我试验过标准振荡器（和它们的那种无息），我设法在所有的振荡器上获利--这完全取决于设置...只是一个随机性或规律性的问题。
 
Комбинатор:
你希望用这种模式取得成果吗？你的内层作为一个中间的压缩器，而不是一个分类器。
这就是我需要的压缩...在一个时间点上（在当前条形图上），64个输入中只有2个输入是不为零的...而网络的任务不是用买入/卖出来划分，而是衡量在给定的输入下出现反弹的概率是多少。还是我的推理有误？
 
-Aleks-:

该阵列是一个有趣的解决方案。各对/各期之间的统计数字是否有差异，一般来说，模式发生的频率变化的稳定性是什么，能不能得到一个积极的预测结果？

关于之字形，我也有一个百分比的解决方案，但我也用更深的历史来计算之字形的参考部分，对照它来比较其他的百分比变化。

众所周知，A.Merrill的形态并没有给出准确的答案，该形态是否会进一步发展（维持趋势）或改变成另一种形态（价格反弹）。这就是为什么我决定使用两个时间框架--一小时和一分钟--来寻找答案。我收集了关于成对复发的统计数据，还没有一个通用的训练字典。然而我确信这种联系一定存在......。否则就不会有和谐的图案：蝴蝶、蝙蝠等。
 
Andrey Emelyanov:
众所周知，A.Merrill的形态并没有给出一个准确的答案，即该形态是否会进一步发展（维持趋势）或改变为另一种形态（价格反弹）。这就是为什么我决定使用两个时间框架--一小时和一分钟--来寻找答案。我收集了关于成对复发的统计数据，还没有一个通用的训练字典。然而我确信这种联系一定存在......。否则就不会有和谐的模式：蝴蝶、蝙蝠等。
人在视觉上感知到的 "蝴蝶、蝙蝠等 "的模型只产生于人的大脑，我认为有必要考虑这个因素，有必要就这个主题研究认知心理学，以了解什么对大脑是必要的，什么对感知模式是不重要的，也就是说，什么错误是可以接受的，什么是不可以的。大脑经常完成它期望看到的东西--它的模式词汇是有限的，所以它把类似的烛台组合放到一张图片中，也就是说，它没有使用确切的数学模型来描述它所看到的东西。
 

我的孩子还是很笨，很沉闷，但已经有了点进展......8个输入指标，1个输出，覆盖层中有15个神经元。2000个输入矢量，10000个训练周期。

这实际上是第三或第四个，都得到了几乎相同的结果。我想我需要更多的神经元和输入矢量，但它需要很长的时间来训练。

我对它应该采取的模式有一个大致的概念，我已经从不同的时间段选择了指标，输出的信息似乎很有意义。

12345678910
新评论