Сергей (Все сообщения пользователя)

function round_step_price(price, ty)
    local x=0
    if (ty=="sell") -- Продаем ->округлить в бОльшую сторону
        x= math.ceil(price/options.price_step) * options.price_step
    else -- Покупаем - округлим в меньшую сторону
        x= math.floor(price/options.price_step) * options.price_step
    end
    return x*1
end

NeuralNetwork = {}
NeuralNetwork.__index = NeuralNetwork
function NeuralNetwork.new(inputs, layers, neyrons) -- Инициализация
 local self = setmetatable({}, NeuralNetwork)
 self.layers=layers -- слоев
 self.inputs=inputs -- входов
 self.neyrons=neyrons --нейронов в слое
 self.k=0.5
 self.e=0.01 -- Скорость обучения
 self.im=0.01 -- импульс
 self.traininig_count=0 --Будем считать обучения

 self.w={}
 self.nout={}
 self.dw={}
 self.delta={}
 self.w[1]={}
 self.nout[1]={}
 self.dw[1]={}
 self.delta[1]={}

 local i
 local l
 for i = 1, self.neyrons, 1 do
      self.w[1][i]={}
      self.dw[1][i]={}
      self.delta[1][i]={}
      self.nout[1][i]={}
      for ii = 1, self.inputs+1, 1 do
          self.w[1][i][ii]=math.random()
          self.dw[1][i][ii]=0
      end
 end

 for l = 2, self.layers, 1 do --перебор остальных слоев
      self.w[l]={}
      self.dw[l]={}
      self.delta[l]={}
      self.nout[l]={}
      for i = 1, self.neyrons, 1 do
          self.w[l][i]={}
          self.dw[l][i]={}
          self.delta[l][i]={}
          self.nout[l][i]={}
          for ii = 1, self.neyrons+1, 1 do
              self.w[l][i][ii]=1*math.random()
              self.dw[l][i][ii]=0
          end
      end
 end
 --Выходной нейрон
 self.w[self.layers+1]={}
 self.dw[self.layers+1]={}
 self.w[self.layers+1][1]={}
 self.dw[self.layers+1][1]={}
 self.delta[self.layers+1]={}
 self.delta[self.layers+1][1]={}
 for ii = 1, self.neyrons+1, 1 do -- +w0
      self.w[self.layers+1][1][ii]=1*math.random()
      self.dw[self.layers+1][1][ii]=0
 end

 return self
end

function NeuralNetwork.Save(self, filename)
    local f,err = io.open(filename,"w")
    if not f then       
       return false
    end
    f:write(table.tostring(self))
    f:close()
    return true
end
function NeuralNetwork.Load(self, filename)
    local f,err = io.open(filename,"r")
    if not f then
       return false
    end
    local tbl = assert(load("return " .. f:read("*a")))
    f:close()
    for k,v in pairs(tbl()) do
        if (type(v)=="table") then 
            self[k]=table_copy(v)
        else
            self[k] = v
        end
      end
    return true
end

function NeuralNetwork.Training(self, data, res) --Одно обучение
    self.traininig_count=self.traininig_count+1 -- счетчик обучений
    local nres=self:Play(data) --Свой результат
    self.delta[self.layers+1][1]=(res-nres) --Начинаем с выходного слоя
    for tmpi = 1, self.neyrons, 1 do -- последний перед выходом слой
        self.delta[self.layers][tmpi] = self.w[self.layers + 1][1][tmpi] * self.delta[self.layers + 1][1]*dsigmoda(self.nout[self.layers][tmpi], self.k)
    end
    for tmpl =self.layers-1, 1, -1 do -- слои
        for tmpn = 1, self.neyrons, 1 do-- нейроны в слое
            self.delta[tmpl][tmpn] = 0
            for tmpi = 1, self.neyrons, 1 do
                self.delta[tmpl][tmpn] = self.delta[tmpl][tmpn] + (self.w[tmpl + 1][tmpi][tmpn] * self.delta[tmpl + 1][tmpi])
            end
            self.delta[tmpl][tmpn] = self.delta[tmpl][tmpn] * dsigmoda(self.nout[tmpl][tmpn],self.k)
        end
    end
    --Теперь правим веса
    --Правим в первом/входном слое *************************** первый(0) *************************************
    for tmpn = 1, self.neyrons, 1 do -- нейроны в слое
        self.dw[1][tmpn][self.inputs + 1] = (self.e * self.delta[1][tmpn] * (1 - self.im)) + (self.im * self.dw[1][tmpn][self.inputs + 1])
        self.w[1][tmpn][self.inputs + 1] = self.w[1][tmpn][self.inputs + 1] + self.dw[1][tmpn][self.inputs + 1]
        for tmpi = 1, self.inputs, 1 do -- нейроны в слое
            self.dw[1][tmpn][tmpi] = (data[tmpi] * self.e * self.delta[1][tmpn] * (1 - self.im)) + (self.im * self.dw[1][tmpn][tmpi])
            self.w[1][tmpn][tmpi] = self.w[1][tmpn][tmpi] + self.dw[1][tmpn][tmpi]
        end
    end
    --Остальные слои
    for tmpl = 2, self.layers, 1 do
        for tmpn = 1, self.neyrons, 1 do
            self.dw[tmpl][tmpn][self.neyrons + 1] = (self.e * self.delta[tmpl][tmpn] * (1 - self.im)) + (self.im * self.dw[tmpl][tmpn][self.neyrons + 1])
            self.w[tmpl][tmpn][self.neyrons + 1] = self.w[tmpl][tmpn][self.neyrons + 1] + self.dw[tmpl][tmpn][self.neyrons + 1]
            for tmpi = 1,  self.neyrons, 1 do --нейроны в слое
                self.dw[tmpl][tmpn][tmpi] = (self.nout[tmpl-1][tmpi] * self.e * self.delta[tmpl][tmpn] * (1 - self.im)) + (self.im * self.dw[tmpl][tmpn][tmpi])
                self.w[tmpl][tmpn][tmpi] = self.w[tmpl][tmpn][tmpi] + self.dw[tmpl][tmpn][tmpi]
            end
        end
    end
    -- Выходной слой из одного нейрона
    self.dw[self.layers+1][1][self.neyrons + 1] = (self.e * self.delta[self.layers + 1][1] * (1 - self.im)) + (self.im * self.dw[self.layers + 1][1][self.neyrons + 1])
    self.w[self.layers+1][1][self.neyrons + 1] = self.w[self.layers + 1][1][self.neyrons + 1] + self.dw[self.layers + 1][1][self.neyrons + 1]
    for tmpi = 1,  self.neyrons, 1 do -- нейроны в слое
        self.dw[self.layers + 1][ 1][tmpi] = (self.nout[self.layers][tmpi] * self.e * self.delta[self.layers + 1][1] * (1 - self.im)) + (self.im * self.dw[self.layers + 1][1][tmpi])
        self.w[self.layers + 1][1][tmpi] = self.w[self.layers + 1][1][tmpi] + self.dw[self.layers + 1][1][tmpi]
    end
end

function NeuralNetwork.Play(self, tick_data) -- Принятие решения
    local l
    local n
    local i
    for l = 1, self.layers, 1 do -- проход по всем слоям, 1 - входной слой
        for n = 1, self.neyrons, 1 do
            local mmax
            if (l==1) then --входной слой
                self.nout[l][n]=1*self.w[l][n][self.inputs+1] --W0 последний
                mmax=self.inputs
            else
                self.nout[l][n]=1*self.w[l][n][self.neyrons+1] --W0 последний
                mmax=self.neyrons
            end
            for i = 1, mmax, 1 do
                if (l==1) then --входной слой
                    self.nout[l][n]=self.nout[l][n]+(tick_data[i]*self.w[l][n][i])  --W0 последний
                else
                    self.nout[l][n]=self.nout[l][n]+(self.nout[l-1][i]*self.w[l][n][i]) --W0 последний
                end
            end
            self.nout[l][n]=sigmoda(self.nout[l][n], self.k)
        end
    end
    --Выходной нейрон
    self.nout[self.layers+1]=self.w[self.layers+1][1][self.neyrons+1] --W0
    for i = 1, self.neyrons, 1 do
        self.nout[self.layers+1]=self.nout[self.layers+1]+(self.nout[self.layers][i]*self.w[self.layers+1][1][i])
    end
    return sigmoda(self.nout[self.layers+1], self.k)
end
function dsigmoda(x, k)
    local r
    r = k * x * (1 - x)
    return r
end
function sigmoda(x, k)
    local r
    r = 1 / (1 + math.exp(-x * k))
    return r
end
function table_copy(originalTable)
    local copyTable = {}
     for k,v in pairs(originalTable) do
       if (type(v)=="table") then 
           copyTable[k]=table_copy(v)
       else
           copyTable[k] = v
       end
     end
    return copyTable
end

--Обучающие данные
local TrainingData={}
for i=1, 100, 1 do
    local d1=math.random() -- Обучающие данные
    local d2=math.random() -- Обучающие данные
    local result=0 -- Правильный ответ
    if (d1>d2) then
        result=1
    end
    local td={d1, d2, result}
    TrainingData[#TrainingData+1]=td
end

--Обучение
local nn=NeuralNetwork.new(2, 3, 3)
for age=1, 100, 1 do -- Эпохи
    for i=1, #TrainingData, 1 do
        local td=TrainingData[i]
        nn:Training(td, td[#td])
    end
end

--Проверка
    local d1=math.random() 
    local d2=math.random() 
    td={d1, d2}
    local result=nn:Play(td)
    PrintDbgStr(d1.." "..d2.." "..result)   
--Сохраним обученную нейронку   
fn=getScriptPath().."\\test.nn"
nn:Save(fn)

local test_tab={}
   if (test_tab[0]==nil) then 
      say("1")
   else
      say("2")
   end

function last_condle() -- самая последняя свеча
   local tmp_max=getNumCandles(options.future.."_price")
   local tab2, n1, tmpname=getCandlesByIndex(options.future.."_price", 0,tmp_max-1, 1) 

        -- Костыль №1
   if (tab2==nil) then
      say(" Ошибка 1748 - нет данных!!! - входим в режим ожидания данных tmp_max="..tmp_max)
      while (tab2==nil) do
         sleep(731)
         tab2, n1, tmpname=getCandlesByIndex(options.future.."_price", 0,tmp_max-1, 1)    
      end 
   end   

   -- Костыль №2
   if (tab2[0]==nil) then -- Тут иногда ошибка "attempt to index a function value (local 'tab2')"
      say(" Ошибка 1739 - нет данных!!! - входим в режим ожидания данных tmp_max="..tmp_max)
      while (tab2[0]==nil) do
         sleep(731)
         tab2, n1, tmpname=getCandlesByIndex(options.future.."_price", 0,tmp_max-1, 1)    
      end 
   end

   return tab2[0]
end

function table_copy(originalTable)
 local copyTable = {}
  for k,v in pairs(originalTable) do
   if (type(v)=="table") then
      copyTable[k]=table_copy(v)
   else
      copyTable[k] = v
   end
  end
 return copyTable
end

function main()
   local t1={}
   t1.x={}
   t1.x.y=1
   local t2=table_copy(t1)
   t2.x.z="Hi!"   
   PrintDbgStr(""..t1.x.z)
end

function table_copy(originalTable)
 local copyTable = {}
  for k,v in pairs(originalTable) do
   if (type(v)==table) then
      copyTable[k]=table_copy(v)
   else
      copyTable[k] = v
   end
  end
 return copyTable
end

x= math.ceil(price/options.price_step) * options.price_step

function save_log(st)
   local path=getScriptPath().."\\"..options.script_name..".log"
   local fn=io.open(path, "a") 
   fn:write(st.."\n")
   fn:close()
end

function save_log(st)
   local path=getScriptPath().."\\"..options.script_name..".log"
   local fn=io.open(path, "a") -- a-дозапись, w-перезапись, r-чтение
   fn:write(st.."\n")
   fn:close()
end

local order_s1=
      {
         ["TRANS_ID"] = tostring(7733113),
         ["CLASSCODE"] = class_code,
         ["ACTION"] = "Ввод заявки",
         ["Класс"] = classcode,
         ["Инструмент"] = sec_code,
         ["Торговый счет"] = acoount,
         ["Тип"] = "Лимитная",
         ["К/П"] = "Купля",  --купля
         ["Цена"] = tostring(p),
         ["Лоты"] = tostring(q),
         ["Условие исполнения"] = "Поставить в очередь"
      }
   local err=sendTransaction(order_s1)

function add_five_ma() -- Добавим к минутным свечам price_con значение 5-ти минутных ma
   local count
   local alfa2=1*2/(1+2)
   local alfa4=1*2/(1+4)

   --в ma4s к минутным свечам добавляем значение ma с интервалом 4 пятиминутного графика, которое соответствует исторической свече
   --в ma4 запишем значения ma с пятиминутного графика, которые видно на графике в моменте (т.е. когда минутная свеча завершена, а
   -- 5-минутная еще нет "дыхание" )
   --Начальные значения - SMA
   count=0 --индекс одноминутных свечей в таблице price_con
   sum_m1=0 -- сумма минутных ma1 (это же средняя цена свечи???)
   for i=1, 4, 1 do -- в первые 3 пятиминутные свечи пишем 0, в 4ю обычное SMA
      for j=1, 5, 1 do -- перебор одноминутных свечей
         price_con[count].ma4s=0
         price_con[count].ma4=0
         sum_m1=sum_m1+ma1[count].high
         count=count+1
      end
   end
   --четвертая пятиминутка на одноминутных свечах
   local ma4s=sum_m1/count
   for j=1, 5, 1 do -- перебор одноминутных свечей
      price_con[14+j].ma4s=ma4s
      price_con[14+j].ma4=0
      sum_m1=sum_m1+ma1[count].high
      count=count+1
   end

   local last_ma4_t5=ma4s -- предыдущее значение ma4
   count = 1 --счетчик одминуных свечей (1..5)
   local ma1s=0
   --  Далее перебор всех одноминутных свечей, кроме уже заданных первых 20ти (0..19)
   for i=20, min_len-1, 1 do -- перебор минутных свечей
      price_con[i].ma4s=0 --определим для последних, попавших в незакрытую 5мин свечу
      ma1s=((ma1s*(count-1))+ma1[i].high)/count --средняя цена в моменте (в незакрытой 5-ти минутной свече) (сумма минутных ma1)
      price_con[i].ma4=(alfa4*(ma1s))+((1-alfa4)*last_ma4_t5) --значение в моменте ("дыхание")

      if (count==5) then -- Закончилась 5-ти мин. свеча - занесем итоговое значение ma4 в ma4s
         for j= 0, -4, -1 do
            price_con[i+j].ma4s=price_con[i].ma4 -- итоговое значение
         end
         count = 0
         last_ma4_t5=price_con[i].ma4 --для следующе свечи
      end
      count=count+1
   end
end