Машинное обучение в трейдинге: теория, модели, практика и алготорговля - страница 2638

                                А что мы прогнозируем на самом деле?

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

например, построим какую то простую тенденцию в виде синусоиды которой подчиняеться(в нашей модели) цена , назовем ее "trend"

par(mar=c(2,2,2,2))
my.sin <- function(ve,a,f,p)    a*sin(f*ve+p)
trend <- my.sin(ve = 1:100,a = 1,f = 0.05,p = 1)+100
plot(trend,t="l")

Простейшая модель цены, легко понять, легко прогнозировать и вообще..

А теперт представим что к "нам на рынок" пришел какой то сильный рыночный покупатель и какое то время делал сильные вливания в в "наш рынок"

layout(1:2, heights = c(10,3))
plot(trend,t="l",lty=2) 
lines(trend+buy)
plot(buy,t="l",col=3,lwd=2)

как видите наш красивая моделька немного нарушелась..

Теперь давайте представим что по цене скажем 99.2 кто то поставил крупный лимитник и выкупает все что ему дают

buy_limit <- trend
for(i in seq_along(trend)) if(buy_limit[i]<=99.2)  buy_limit[i] <- 99.2
layout(1:1)
plot(trend,t="l")
lines(buy_limit+buy,lty=2)
segments(10,99.2,100,99.2,lty=2,col=3)

Итого получаем уже такую кривую модель цены, зато более близкую к реальности

plot(trend,t="l",col=8,lty=2)
lines(buy_limit + buy ,t="l")

Также для еще болльшего реализма добавим шум, ну например торговлю мелкоты или маркетмейкера

noise <- rnorm(100,sd = 0.05)
plot(trend,t="l",col=8,lty=2)
lines(buy_limit+buy+noise)

Вот, как то так можно смотреть на рынок, как на сложнжый процесс..

А теперь интересно поразмышлять. Когда мы прогнозируем цену, что именно мы прогнозируем?   тенденцию? рыночного покупателя? лимитного покупателя? шум? :) и стоит ли прогнозировать это все вместе?

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

Граматическая эволюция / символьная регресия, более продвинутая версия генетического програмирования..

С помощью этих инструментов можно на автомате икать закономерности, любых видов

например можно искать оптимальное управление индикатором через формулу

создаем шаблон функций  (область поиска)

library(gramEvol)
ruleDef <- list(expr  = grule(op(expr, expr), func(expr), var),
                func  = grule(sin, cos, log, sqrt),
                op    = grule("+", "-", "*","/"),
                var   = grule(distance, distance^n),
                n     = grule(1, 2, 3, 4))

grammarDef <- CreateGrammar(ruleDef)
gr <- GrammarRandomExpression(grammarDef,numExpr = 10,max.depth = 5)
q <- as.matrix(unlist(lapply(gr,as.character)),ncol=1)
q

и оно на автомате создает формулы :

[1,] "sqrt(log(cos(sqrt(cos(distance^2)))))"                                                                  
 [2,] "sin(log(sqrt(sin(sqrt(distance * distance))) * (sin(log(distance^3)) - cos(cos(distance)) - distance)))"
 [3,] "(sin(distance * sqrt(sin(distance * sqrt(distance^3)))) + distance^1)/distance"                         
 [4,] "sin(log(log(distance^4)))"                                                                              
 [5,] "distance"                                                                                               
 [6,] "distance^4"                                                                                             
 [7,] "log(sin(distance)) * (log(distance) - cos(distance^4 - distance^4))"                                    
 [8,] "distance^1"                                                                                             
 [9,] "distance"                                                                                               
[10,] "log(distance) * (distance/log((distance^4 - distance^3) * distance^2))"        

 которые потом генетикой ищеться лучшее решение

=====================

Или можно создавать лог. правила , таким образом искать закономерности

Опять   создаем шаблон функций  (область поиска)

library(gramEvol)
ruleDef <- list(
  expr = grule(expr & sub.expr, 
               expr | sub.expr, 
               sub.expr),
  sub.expr = grule( com(var, var) ),
  com = grule(">=","<="),
  var = grule(x,y,w,z,q,y,r)
  )

grammarDef <- CreateGrammar(ruleDef)
gr <- GrammarRandomExpression(grammarDef,numExpr = 15,max.depth = 3)

q <- as.matrix(unlist(lapply(gr,as.character)),ncol=1)
q

И на выходе получаем правила

[1,] "x >= y"                  
 [2,] "y <= y | y >= y | w >= y"
 [3,] "y <= x"                  
 [4,] "y <= y"                  
 [5,] "y <= r"                  
 [6,] "z <= z"                  
 [7,] "y <= y"                  
 [8,] "x <= y"                  
 [9,] "z <= y | y >= z & r >= y"
[10,] "z >= x"                  
[11,] "y >= y | q >= y | q >= q"
[12,] "y >= y | q <= y | z >= q"
[13,] "y >= y | x <= y | x >= x"
[14,] "y >= r"                  
[15,] "y >= w"

которые потом тестируються на пригодность генетикой

=============================

Если у вас есть ТС и вы хотите улучшыть ее но не хватает фантазии чтобы перепробовать милионы вариантов, то можно попробовать сделать это с помощью алгоритма.

например точка входа у нас :  пробитие болинжера ценой вниз ( "PRICE < BOLINGER" )

Мы добавляем это правило в нашу граматику

library(gramEvol)
ruleDef <- list(
  expr = grule(expr & sub.expr, 
               expr | sub.expr, 
               sub.expr),
  sub.expr = grule( com(var, var)  ,  PRICE < BOLINGER),
  com = grule(">=","<="),
  var = grule(x,y,w,z,q,y,r)
  )

grammarDef <- CreateGrammar(ruleDef)
gr <- GrammarRandomExpression(grammarDef,numExpr = 15,max.depth = 3)

q <- as.matrix(unlist(lapply(gr,as.character)),ncol=1)
q

Правила немножно дебильные но это потому что генерируються рандомно

[1,] "y >= q"                                                                                                        
 [2,] "PRICE < BOLINGER & y >= y | x >= x"                                                                            
 [3,] "PRICE < BOLINGER | PRICE < BOLINGER & x <= y | y <= w"                                                         
 [4,] "r <= y & PRICE < BOLINGER | w >= x | y <= x"                                                                   
 [5,] "PRICE < BOLINGER | PRICE < BOLINGER | y <= y & PRICE < BOLINGER"                                               
 [6,] "PRICE < BOLINGER"                                                                                              
 [7,] "PRICE < BOLINGER & PRICE < BOLINGER & z <= x | PRICE < BOLINGER & PRICE < BOLINGER | PRICE < BOLINGER | z <= x"
 [8,] "y <= y | PRICE < BOLINGER | x <= y | PRICE < BOLINGER | PRICE < BOLINGER"                                      
 [9,] "PRICE < BOLINGER & x <= y | y <= q & PRICE < BOLINGER"                                                         
[10,] "q >= z & PRICE < BOLINGER | q >= w & y <= x"                                                                   
[11,] "PRICE < BOLINGER | PRICE < BOLINGER"                                                                           
[12,] "w >= y"                                                                                                        
[13,] "PRICE < BOLINGER"                                                                                              
[14,] "y <= y & PRICE < BOLINGER | q >= x | PRICE < BOLINGER"                                                         
[15,] "q >= x" 

Суть в том что мы сильно снижаем пространство поиска, если добавим свое правило

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