Любые вопросы новичков по MQL4 и MQL5, помощь и обсуждение по алгоритмам и кодам - страница 2058

 
Подскажите, пожалуйста, как создать ещё слои?
Хочу налепить слоёв 10

matrix weights1weights2weights3;               // матрицы весовых коэффициентов
matrix output1output2result;                   // матрицы выходов нейронных слоев
input int layer1 = 200;                            // размер 1-го скрытого слоя
input int layer2 = 200;                            // размер 2-го скрытого слоя
input int Epochs = 20000;                          // количество эпох обучения
input double lr = 3e-6;                            // коэффициент скорости обучения
input ENUM_ACTIVATION_FUNCTION ac_func = AF_SWISH// функция активации



//+------------------------------------------------------------------+
//| Функция запуска скрипта                                          |
//+------------------------------------------------------------------+


void OnStart()
  {
//---
   int train = 1000;    // размер обучающей выборки
   int test = 10;       // размер тестовой выборки
   matrix m_datam_target;
//--- генерируем обучающую выборку
   if(!CreateData(m_datam_targettrain))  
      return;
//--- обучаем модель
   if(!Train(m_datam_targetEpochs))      
      return;
//--- генерируем тестовую выборку
   if(!CreateData(m_datam_targettest))   
      return;
//--- тестирование модели
   Test(m_datam_target);                   
  }


//+------------------------------------------------------------------+
//| Метод генерации выборки                                          |
//+------------------------------------------------------------------+


bool CreateData(matrix &datamatrix &targetconst int count)
  {
//--- инициализируем матрицы исходных данных и результатов
   if(!data.Init(count3) || !target.Init(count1))
      return false;
//--- заполняем матрицу исходных данных случайными значениями
   data.Random(-1010);                     
//--- рассчитываем целевые значения для обучающей выборки
   vector X1 = MathPow(data.Col(0) + data.Col(1) + data.Col(1), 2);
   vector X2 = MathPow(data.Col(0), 2) + MathPow(data.Col(1), 2) + MathPow(data.Col(2), 2);
   if(!target.Col(X1 / X20))
      return false;
//--- возвращаем результат
   return true;
  }


//+------------------------------------------------------------------+
//| Метод обучения модели                                            |
//+------------------------------------------------------------------+


bool Train(matrix &datamatrix &targetconst int epochs = 10000)
  {
//--- создаем модель
   if(!CreateNet())
      return false;
//--- обучаем модель
   for(int ep = 0ep < epochsep++)
     {
      //--- прямой проход
      if(!FeedForward(data))
         return false;
      PrintFormat("Epoch %d, loss %.5f"epresult.Loss(targetLOSS_MSE));
      //--- обратный проход и обновление матриц весов
      if(!Backprop(datatarget))
         return false;
     }
//--- возвращаем результат
   return true;
  }


//+------------------------------------------------------------------+
//| Метод создания модели                                            |
//+------------------------------------------------------------------+


bool CreateNet()
  {
//--- инициализируем матрицы весов
   if(!weights1.Init(4layer1) || !weights2.Init(layer1 + 1layer2) || !weights3.Init(layer2 + 11))
      return false;
//--- заполняем матрицы весов случайными значениями
   weights1.Random(-0.10.1);
   weights2.Random(-0.10.1);
   weights3.Random(-0.10.1);
//--- возвращаем результат
   return true;
  }


//+------------------------------------------------------------------+
//| Метод прямого прохода                                            |
//+------------------------------------------------------------------+


bool FeedForward(matrix &data)
  {
//--- проверяем размер исходных данных
   if(data.Cols() != weights1.Rows() - 1)
      return false;
//--- вычисляем первый нейронный слой
   matrix temp = data;
   if(!temp.Resize(temp.Rows(), weights1.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights1.Rows() - 1))
      return false;
   output1 = temp.MatMul(weights1);
//--- вычисяем функцию активации
   if(!output1.Activation(tempac_func))
      return false;
//--- вычисляем второй нейронный слой
   if(!temp.Resize(temp.Rows(), weights2.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights2.Rows() - 1))
      return false;
   output2 = temp.MatMul(weights2);
//--- вычисляем функцию активации
   if(!output2.Activation(tempac_func))
      return false;
//--- вычисляем третий нейронный слой
   if(!temp.Resize(temp.Rows(), weights3.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights3.Rows() - 1))
      return false;
   result = temp.MatMul(weights3);
//--- возвращаем результат
   return true;
  }


//+------------------------------------------------------------------+
//| Метод обратного прохода                                          |
//+------------------------------------------------------------------+
bool Backprop(matrix &datamatrix &target)
  {
//--- проверяем размерность матрицы целевых значений
   if(target.Rows() != result.Rows() ||
      target.Cols() != result.Cols())
      return false;
//--- определяем отклонение расчетных значений от целевых
   matrix loss = (target - result) * 2;
//--- проводим градиент до предыдущего слоя
   matrix gradient = loss.MatMul(weights3.Transpose());
//--- обновляем матрицу весов последнего слоя
   matrix temp;
   if(!output2.Activation(tempac_func))
      return false;
   if(!temp.Resize(temp.Rows(), weights3.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights3.Rows() - 1))
      return false;
   weights3 = weights3 + temp.Transpose().MatMul(loss) * lr;
//--- корректируем градиент ошибки на производную функции активации
   if(!output2.Derivative(tempac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- опускаем градиент на слой ниже
   gradient = loss.MatMul(weights2.Transpose());
//--- обновляем матрицу весов 2-го скрытого слоя
   if(!output1.Activation(tempac_func))
      return false;
   if(!temp.Resize(temp.Rows(), weights2.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights2.Rows() - 1))
      return false;
   weights2 = weights2 + temp.Transpose().MatMul(loss) * lr;
//--- корректируем градиент ошибки на производную функции активации
   if(!output1.Derivative(tempac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- обновляем матрицу весов 1-го скрытого слоя
   temp = data;
   if(!temp.Resize(temp.Rows(), weights1.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights1.Rows() - 1))
      return false;
   weights1 = weights1 + temp.Transpose().MatMul(loss) * lr;
//--- возвращаем результат
   return true;
  }


//+------------------------------------------------------------------+
//| Метод тестирования модели                                        |
//+------------------------------------------------------------------+


bool Test(matrix &datamatrix &target)
  {
//--- прямой проход на тестовых данных
   if(!FeedForward(data))
      return false;
//--- выводим в лог результаты расчета модели и истинные значения
   PrintFormat("Test loss %.5f"result.Loss(targetLOSS_MSE));
   ulong total = data.Rows();
   for(ulong i = 0i < totali++)
      PrintFormat("(%.2f + %.2f + %.2f)^2 / (%.2f^2 + %.2f^2 + %.2f^2) =  Net %.2f, Target %.2f"data[i0], data[i1], data[i2],
                  data[i0], data[i1], data[i2], result[i0], target[i0]);
//--- возвращаем результат
   return true;
  }


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


 
Ivan Butko #:
Подскажите, пожалуйста, как создать ещё слои?
Хочу налепить слоёв 10

Не знаю,  к каким данным вы собираетесь применять нейронные сети, но хочу заметить, что увеличение нейронных слоев вовсе не панацея. Всё зависит от данных и если сеть не нашла зависимостей, по которым можно будет предсказать выходные данные, то пусть слоев будет 1000, это не поможет.

 
f1nik #:

Не знаю,  к каким данным вы собираетесь применять нейронные сети, но хочу заметить, что увеличение нейронных слоев вовсе не панацея. Всё зависит от данных и если сеть не нашла зависимостей, по которым можно будет предсказать выходные данные, то пусть слоев будет 1000, это не поможет.

Мне уже говорили это здешние гуру)))
К обычной цене пробую, разность цен и так далее, ищу что заработает.

Но, у меня метод тыка и очень любопытно, как на практике отличается сеть с 1-2-мя слоями и с 10-ю и больше

 
Доброго времени суток! 
Меня заинтересовала тема цифровых фильтров, и я пока не могу найти какую-то объёмную и чётко структурированную информацию о том какие они вообще бывают и примеры кода

Вот пример одного из набор весов:

res=
  0.1136491141667*B1[i]
+0.1123130870080*B1[i+1]
+0.1096691394261*B1[i+2]
+0.1057837207790*B1[i+3]
+0.1007420961698*B1[i+4]
+0.0946599675379*B1[i+5]
+0.0876755484183*B1[i+6]
+0.0799429655454*B1[i+7]
+0.0716292336416*B1[i+8]
+0.0629123835413*B1[i+9]
+0.0539767262326*B1[i+10]
+0.0450048491714*B1[i+11]
+0.0361703734359*B1[i+12]
+0.02763520549089*B1[i+13]
+0.01955011451800*B1[i+14]
+0.01205357915205*B1[i+15]
+0.00525211553366*B1[i+16]
-0.000770477101024*B1[i+17]
-0.00593916191975*B1[i+18]
-0.01022805895137*B1[i+19]
-0.01361544672818*B1[i+20]
-0.01611640231317*B1[i+21]
-0.01776260795296*B1[i+22]
-0.01860554342447*B1[i+23]
-0.01871505916941*B1[i+24]
-0.01817487448682*B1[i+25]
-0.01707856129273*B1[i+26]
-0.01552770218471*B1[i+27]
-0.01362988259084*B1[i+28]
-0.01149332680480*B1[i+29]
-0.00921892385382*B1[i+30]
-0.00689459719023*B1[i+31]
-0.00459651305691*B1[i+32]
-0.002411870743968*B1[i+33]
-0.000431732873329*B1[i+34]
+0.001353807064687*B1[i+35]
+0.002857282707287*B1[i+36]
+0.00408190921586*B1[i+37]
+0.00501143566228*B1[i+38]
+0.00565074521587*B1[i+39]
+0.00601564306030*B1[i+40]
+0.00613066979989*B1[i+41]
+0.00602923574050*B1[i+42]
+0.00575258932729*B1[i+43]
+0.00534744169195*B1[i+44]
+0.00486457915178*B1[i+45]
+0.00435951288835*B1[i+46]
+0.00389329662905*B1[i+47]
+0.00353234960893*B1[i+48]
+0.00335331131328*B1[i+49]
+0.00344636014208*B1[i+50]
-0.00908964634931*B1[i+51];


Подскажите пожалуйста где найти материал о том по какой логике формируются эти коэффициенты - я хочу именно разобраться в сути и самостоятельно воссоздать набор этих весов, но уже понимая как и что можно менять
Индикаторы: volatility_Bar
Индикаторы: volatility_Bar
  • 2020.01.07
  • www.mql5.com
Статьи и техническая библиотека по автоматическому трейдингу: Индикаторы: volatility_Bar
 
Alexandr Sokolov #:
Доброго времени суток! 
Меня заинтересовала тема цифровых фильтров, и я пока не могу найти какую-то объёмную и чётко структурированную информацию о том какие они вообще бывают и примеры кода

Вот пример одного из набор весов:



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

Неплохая статья

Самому ЦФ рассчитать, достаточно не простая задача по объему.

Ричард Хэмминг: Глава 14. Цифровые фильтры — 1
Ричард Хэмминг: Глава 14. Цифровые фильтры — 1
  • 2018.05.03
  • habr.com
«Цель этого курса — подготовить вас к вашему техническому будущему.» Привет, Хабр. Помните офигенную статью «Вы и ваша работа» (+219, 2372 в закладки, 375k прочтений)? Так вот у Хэмминга (да, да, самоконтролирующиеся и самокорректирующиеся коды Хэмминга) есть целая книга, написанная по мотивам его лекций. Мы ее переводи, ведь мужик дело...
 
to_ha #:

Так а что не нравится???

Форма другая и сдвиг. Не понимаю.

 
Valeriy Yastremskiy #:

Неплохая статья

Самому ЦФ рассчитать, достаточно не простая задача по объему.

Благодарю 
 
Александр #:

Форма другая и сдвиг. Не понимаю.

Сдвиг... Может это вся доступная история по этому инструменту у брокера... И фигнюшкой этой и так на пол экрана сдвинут график

А 
Cl_Op_Vol[i] 

видать рисует кривую по ценам закрытиям баров...

 
Александр #:
ArraySetAsSeries()
 

здравствуйте!

к простенькому советнику пытаюсь приделать фильтр работы по времени.

нашел пример кода работы по времени, вставил в код советника, но сов всё равно открывает сделки по сигналу, беж учета времени.

В журнале пишет: 2022.10.13 17:43:09.970 2022.10.12 21:15:00  SMA по времени USDJPY,M15: Alert: Операции запрещены

однако сделки идут (в тестере стратегий). Подскажите пожалуйста, что я упускаю?

вот такой простенький код:

//+-----------------------------------------------------------------------------------------------+
//|                                                                               SMA рабочий.mq4 |
//|                                                                                               |
//|                                                                                               |
//+-----------------------------------------------------------------------------------------------+
#property copyright "Copyright 2021"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
//Перечисление всех часов. Это необходимо для меню ввода часа.
enum Enum_Hour{
   h00=00,     //00:00
   h01=01,     //01:00
   h02=02,     //02:00
   h03=03,     //03:00
   h04=04,     //04:00
   h05=05,     //05:00
   h06=06,     //06:00
   h07=07,     //07:00
   h08=08,     //08:00
   h09=09,     //09:00
   h10=10,     //10:00
   h11=11,     //11:00
   h12=12,     //12:00
   h13=13,     //13:00
   h14=14,     //14:00
   h15=15,     //15:00
   h16=16,     //16:00
   h17=17,     //17:00
   h18=18,     //18:00
   h19=19,     //19:00
   h20=20,     //20:00
   h21=21,     //21:00
   h22=22,     //22:00
   h23=23,     //23:00
};
 
// Параметры советника
input string  sParametersEA = "";     // Параметры советника
input double  Lot           = 0.01;   // Количество лотов
input int     StopLoss      = 560;    // Стоп (SL)
input int     TakeProfit    = 200;    // Тейк (TP)

input int     Slippage      = 3;      // Проскальзование (в пунктах)
input int     Magic         = 1;      // Индентификатор советника
input int     DigitsLot     = 2;      // Точность лотности
input Enum_Hour StartHour   = h07;      //Час начала работы.
input Enum_Hour LastHour    = h17;       //Час окончания работы.

input string  sParametersMA = "";     // Параметры индикатора
input int     PeriodMA      = 14;     // Период мувинга
input int     MovingShift   = 1;      // Сдвиг мувинга
// Глобальные переменные
datetime Start,newbar;
double dMA;
bool CheckActiveHours(){
   //По умолчанию операции отключены
   bool OperationsAllowed=false;
   //Проверяем, находится ли текущий час между разрешенными часами работы, если да, то возвращаем true.
   if(StartHour==LastHour && Hour()==StartHour) OperationsAllowed=true;
   if(StartHour<LastHour && Hour()>=StartHour && Hour()<=LastHour) OperationsAllowed=true;
   if(StartHour>LastHour && ((Hour()>=LastHour && Hour()<=23) || (Hour()<=StartHour && Hour()>0))) OperationsAllowed=true;
   return OperationsAllowed;
}

//+-----------------------------------------------------------------------------------------------+
int OnInit()
  {
Start          = TimeCurrent();
return(INIT_SUCCEEDED);
 
  }
//+-----------------------------------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

  }
//+-----------------------------------------------------------------------------------------------+
void OnTick()
  {
  
// Получим значение индикатора
   dMA = iMA(Symbol(), 0,PeriodMA, MovingShift, MODE_SMA, PRICE_CLOSE, 0); // MODE_SMA - простое усреднение , значение 0. PRICE_CLOSE- цена закрытия, значение 0.

// Если нет открытых ордеров, то входим в условие
      if(CountOrders()==0)
     {
      
// Если появился сигнал на покупку, то откроем ордер на покупку
      if(bSignalBuy() == true)
         vOrderOpenBuy();

// Если появился сигнал на продажу, то откроем ордер на продажу
      if(bSignalSell() == true)
         vOrderOpenSell();
     }
if(CheckActiveHours()) Alert("Операции разрешены");  else Alert("Операции запрещены");
   }
//+-----------------------------------------------------------------------------------------------+
//|                                                             Функция проверки открытых оредров |
//+-----------------------------------------------------------------------------------------------+
int CountOrders() 
  {
   int cnt=0;
   int i=OrdersTotal()-1;
   for(int pos=i;pos>=0;pos--)
     {
      if(OrderSelect(pos, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol()==_Symbol)
           {
            if(OrderMagicNumber()==Magic) cnt++;
           }
        }
     }
   return(cnt);
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                             Функция поиска сигнала на покупку |
//|                    Open[1] и Close[1]- цены открытия и закрытия каждого бара текущего графика |
//+-----------------------------------------------------------------------------------------------+
bool bSignalBuy()
  {
   if(dMA > Open[1] && dMA < Close[1])  
      return(true);

   return(false);
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                             Функция поиска сигнала на продажу |
//+-----------------------------------------------------------------------------------------------+
bool bSignalSell()
  {
   if(dMA < Open[1] && dMA > Close[1])
      return(true);

   return(false);
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                            Функция открытия ордера на покупку |
//+-----------------------------------------------------------------------------------------------+
void vOrderOpenBuy()
  {
   if(newbar!=Time[0])
     {
   // Тикет ордера
      int iOTi = 0;   
   
      iOTi = OrderSend(Symbol(), OP_BUY, Lot, Ask, Slippage, 0, 0, "", Magic, 0, clrNONE);
      
   // Проверим открылся ли ордер
      if(iOTi > 0)
   // Есди да, то выставим уровни убытка и прибыли
         vOrderModify(iOTi);
      else
   // Если нет, то получим ошибку
         vError(GetLastError());
      newbar=Time[0];
     }
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                            Функция открытия ордера на продажу |
//+-----------------------------------------------------------------------------------------------+
void vOrderOpenSell()
  {
   if(newbar!=Time[0])
     {
   // Тикет ордера  
      int iOTi = 0;   
   //Print(bCheckOrders());
      iOTi = OrderSend(Symbol(), OP_SELL, Lot, Bid, Slippage, 0, 0, "", Magic, 0, clrNONE);
   
   // Проверим открылся ли ордер
      if(iOTi > 0)
   // Есди да, то выставим уровни убытка и прибыли
         vOrderModify(iOTi);
      else
   // Если нет, то получим ошибку
         vError(GetLastError());
      newbar=Time[0];
     }
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                                    Функция модификации ордера |
//+-----------------------------------------------------------------------------------------------+
void vOrderModify(int iOTi)
  {
   int    iOTy = -1;    // Тип ордера
   double dOOP = 0;     // Цена открытия ордера
   double dOSL = 0;     // Стоп Лосс
   int    iMag = 0;     // Идентификатор советника
   double dSL  = 0;     // Уровень убытка
   double dTP  = 0;     // Уровень прибыли

// Выберем по тикету открытый ордер, получим некоторые значения
   if(OrderSelect(iOTi, SELECT_BY_TICKET, MODE_TRADES))
     {
      iOTy = OrderType();
      dOOP = OrderOpenPrice();
      dOSL = OrderStopLoss();
      iMag = OrderMagicNumber();
     }

// Если ордер открыл данный советник, то входим в условие
   if(OrderSymbol() == Symbol() && OrderMagicNumber() == iMag)
     {
// Если Стоп Лосс текущего ордера равен нулю, то модифицируем ордер
      if(dOSL == 0)
        {
         if(iOTy == OP_BUY)
           {
            dSL = NormalizeDouble(dOOP - StopLoss * Point, Digits);
            dTP = NormalizeDouble(dOOP + TakeProfit * Point, Digits);

            bool bOM = OrderModify(iOTi, dOOP, dSL, dTP, 0, clrNONE);
           }

         if(iOTy == OP_SELL)
           {
            dSL = NormalizeDouble(dOOP + StopLoss * Point, Digits);
            dTP = NormalizeDouble(dOOP - TakeProfit * Point, Digits);

            bool bOM = OrderModify(iOTi, dOOP, dSL, dTP, 0, clrNONE);
           }
        }
     }
  }
//+-----------------------------------------------------------------------------------------------+
//|                                                                      Функция обработки ошибок |
//+-----------------------------------------------------------------------------------------------+
void vError(int iErr)
  {
   switch(iErr)
     {
      case 129:   // Неправильная цена
      case 135:   // Цена изменилась
      case 136:   // Нет цен
      case 138:   // Новые цены
         Sleep(1000);
         RefreshRates();
         break;

      case 137:   // Брокер занят
      case 146:   // Подсистема торговли занята
         Sleep(3000);
         RefreshRates();
         break;
     }
  }

Причина обращения: