Aprendizado de máquina no trading: teoria, prática, negociação e não só - página 2633

[Andrey Khatimlianskii]

Maxim Dmitrievsky #:

Baixe o bot do mercado, execute-o no testador MT5, depois há uma opção para salvar o relatório com todas as negociações e outras informações

Você pode automatizar, incluindo a execução do teste e o upload de negócios para o csv -https://www.mql5.com/ru/code/26132

[[Excluído]]

mytarmailS #:

Uma estratégia de ouro do mercado))

Curva de capital no meu testador.

jogou-o no tslab para ter uma melhor aparência

Parece que é uma boa combinação.

Eu olhei para os ofícios.

Eu olhava para ele como se fosse um comerciante manual com um algoritmo de negociação extremamente longo e vago.

Forrest certamente não conseguiu identificar nada, mas foi interessante e informativo ))))

Portanto, você precisa ler qual o cronograma e ensinar dois modelos. Um para o comércio, o outro para o tempo. Ou multiclasse. Veja a descrição do bot, talvez seja ruim e não sirva

[[Excluído]]

Andrey Khatimlianskii #:

Pode ser automatizado, incluindo a execução de um teste e o upload de transações para o csv -https://www.mql5.com/ru/code/26132

Sim, obrigado

[[Excluído]]

Dmytryi Voitukhov #:

Pode ser útil... Eu tenho um sem recorrência de muitos para muitos. E sem camadas de convolução. E eu escolhi este modelo depois de analisar o mecanismo neurônico. Estamos procurando um denominador comum aqui, não estamos? Argumento.

Não tenho certeza do que preciso argumentar.

[mytarmailS]

Aleksey Nikolayev #:

Obrigado, vou dar uma olhada.

Ainda assim, conosco, a ordem importa. É sempre possível, por exemplo, obter a SB baralhando os incrementos aleatoriamente.

Também me lembrei que uma vez você escreveu aqui sobre mineração de padrões sequenciais e problema de alinhamento sequencial. Também parece ser um dos métodos para resolver o problema. Embora pertencer a uma classe não signifique necessariamente que elas sejam semelhantes.

apriori_cspade <- function(apri_supp=0.1,arpi_conf=0.1, liS , 
                             maxgap=NULL, maxlen=5,rhs=NULL,
                             apri_maxlen=2,apri_minlen=2,verbose=T,
                             redundant.rules = F, cspade_supp=0.5 , cspade_conf=0.5){
    
    
    
    library(arules)
    
    
    targ <- NULL
    if(!is.null(rhs))  {
      targ <- list(rhs=rhs, default="lhs")
      apri  <- apriori(liS, parameter=list(support=apri_supp, 
                                          confidence=arpi_conf,
                                          minlen=apri_minlen,
                                          maxlen=apri_maxlen), 
                                          appearance = targ,
                             control = list(verbose=verbose))
    }
   
    
    if(is.null(rhs)){
      apri <- apriori(liS, parameter=list(support=apri_supp, 
                                          confidence=arpi_conf, 
                                          target="rules",
                                          minlen=apri_minlen,
                                          maxlen=apri_maxlen),
                              control = list(verbose=verbose))
    }
    
    ar <- as(apri,"data.frame")
    ar <- as.character(ar$rules)
    ar <- gsub("[{}>]","" ,ar)
    ar <- unlist(stringr::str_split(ar ,pattern = "="))
    ar <- ar[!duplicated(ar)]
    ar <- stringr::str_trim(ar)
    for(i in 1:length(liS))   liS[[i]] <-  liS[[i]]  [ liS[[i]]  %in% ar ]
    
    
    
    liS <- liS[  unlist(lapply(liS ,function(x) length(x)>2 ))  ]
    
    
    if(  length(liS) <= 0 ) return(NULL)
    
    
    
    
    
    library(arulesSequences)
    cspade.form <- as.data.frame(matrix(ncol = 4,nrow = 0))
    for(i in 1:length(liS)){
      
      Q <- liS[[i]]
      cspade.form <- rbind(cspade.form,
                           cbind.data.frame( ID = rep(i,length(Q)),
                                             evID = 1:length(Q),
                                             SIZE = rep(1,length(Q)),
                                             ITEM = Q))}
    
    
    write.table(cspade.form , file = "D:\\R2\\arulesSeq\\seq\\temp.txt",
                append = F,sep = ",",row.names = F,col.names = F)
    
    x <- read_baskets(con = "D:\\R2\\arulesSeq\\seq\\temp.txt",sep = ",",
                      info = c("sequenceID","eventID","SIZE"))
    
    mod <- cspade(x, parameter=list(support = cspade_supp,
                                    maxlen = maxlen,
                                    maxgap=maxgap),
                                  control=list(verbose = verbose))
    gc(reset = T,verbose = F)
    
    rules <- ruleInduction(mod, confidence = cspade_conf, control=list(verbose = verbose))
    if(redundant.rules) rules <- rules[!is.redundant(rules)]
    
    final <- as(rules,"data.frame")
    
    #  parse rules
    R <- final$rule
    R <- gsub( "[\"<>{}]","",R)
    R <- stringr::str_split(gsub("=",",",R) , pattern = ",")
    R <- lapply(R,trimws)
    
    li <- list(rules=final, parse.rules=R)
    
    return(li)}

dados

set.seed(123)
>  li <- list()
>  for(i in 1:100){
+    li <- append(li,  
+                 list(c(letters[sample(1:10,sample(5:10,1))] ,   sample(c("buy","sell"),1)))
+    )}
>  
>  head(li)
[[1]]
[1] "c"    "b"    "f"    "j"    "e"    "d"    "i"    "sell"

[[2]]
[1] "j"    "e"    "c"    "h"    "a"    "sell"

[[3]]
[1] "i"   "c"   "h"   "b"   "g"   "buy"

[[4]]
 [1] "c"   "d"   "f"   "a"   "j"   "e"   "i"   "h"   "b"   "g"   "buy"

executamos a função e procuramos por seqüências que levem a nossas marcas

ac <- apriori_cspade(liS = li,apri_supp = 0.1,
                      arpi_conf = 0.5,
                      rhs = c("buy","sell"),cspade_supp = 0.1,redundant.rules = T)

 ac
$rules
                                rule support confidence      lift
29          <{"a"},{"f"}> => <{"j"}>    0.10  0.5000000 0.7246377
56          <{"b"},{"f"}> => <{"i"}>    0.12  0.6000000 0.8333333
80          <{"e"},{"a"}> => <{"h"}>    0.14  0.5000000 0.6666667
98          <{"i"},{"e"}> => <{"g"}>    0.11  0.5000000 0.6329114
149         <{"b"},{"e"}> => <{"d"}>    0.11  0.5789474 0.7617729
168             <{"a"}> => <{"buy"}>    0.45  0.6081081 1.0484623
169             <{"b"}> => <{"buy"}>    0.44  0.6027397 1.0392064
170             <{"c"}> => <{"buy"}>    0.47  0.6103896 1.0523959
171             <{"d"}> => <{"buy"}>    0.46  0.6052632 1.0435572
172             <{"e"}> => <{"buy"}>    0.38  0.5757576 0.9926855
173             <{"f"}> => <{"buy"}>    0.42  0.6000000 1.0344828
174             <{"g"}> => <{"buy"}>    0.47  0.5949367 1.0257529
175             <{"h"}> => <{"buy"}>    0.43  0.5733333 0.9885057
176             <{"i"}> => <{"buy"}>    0.41  0.5694444 0.9818008
177             <{"j"}> => <{"buy"}>    0.45  0.6521739 1.1244378
178       <{"j"},{"i"}> => <{"buy"}>    0.17  0.6800000 1.1724138
182       <{"j"},{"g"}> => <{"buy"}>    0.18  0.6923077 1.1936340
183       <{"g"},{"j"}> => <{"buy"}>    0.18  0.6666667 1.1494253
184       <{"j"},{"f"}> => <{"buy"}>    0.14  0.7000000 1.2068966
185       <{"f"},{"j"}> => <{"buy"}>    0.21  0.7000000 1.2068966
187       <{"e"},{"j"}> => <{"buy"}>    0.17  0.7083333 1.2212644
189       <{"d"},{"j"}> => <{"buy"}>    0.23  0.7666667 1.3218391
191       <{"c"},{"j"}> => <{"buy"}>    0.25  0.7142857 1.2315271
192       <{"j"},{"b"}> => <{"buy"}>    0.16  0.6666667 1.1494253
194       <{"j"},{"a"}> => <{"buy"}>    0.14  0.6666667 1.1494253
195       <{"a"},{"j"}> => <{"buy"}>    0.22  0.7333333 1.2643678
196 <{"g"},{"c"},{"j"}> => <{"buy"}>    0.10  1.0000000 1.7241379
197       <{"i"},{"h"}> => <{"buy"}>    0.17  0.5862069 1.0107015
198       <{"h"},{"i"}> => <{"buy"}>    0.17  0.6071429 1.0467980
204       <{"e"},{"i"}> => <{"buy"}>    0.17  0.6538462 1.1273210
207       <{"i"},{"c"}> => <{"buy"}>    0.16  0.6956522 1.1994003
210       <{"b"},{"i"}> => <{"buy"}>    0.20  0.7692308 1.3262599
212       <{"a"},{"i"}> => <{"buy"}>    0.15  0.7142857 1.2315271
213 <{"c"},{"f"},{"i"}> => <{"buy"}>    0.10  0.6666667 1.1494253

A função é "suja", mas funciona, muda os caminhos na função para suas próprias necessidades e instala os pacotes corretos.

Mas você deve saber que os algoritmos que procuram tais "seqüências esparsas" deste tipo são muito vorazes, há uma enorme busca, apesar do fato de que o algoritmo em si faz uma busca eficiente e é escrito em C++

[Aleksey Nikolayev]

mytarmailS #:

dados

executar a função e procurar seqüências que levem a nossas etiquetas

A função é "suja", eu mesmo a escrevi, mas funciona, mude os caminhos na função para você mesmo e instale os pacotes corretos

Mas você deve saber que os algoritmos que procuram tais "seqüências esparsas" deste tipo são muito vorazes, há uma enorme busca, apesar do fato de que o algoritmo em si faz uma busca eficiente e é escrito em C++

Obrigado, vou pensar em como acrescentar isso aos meus problemas.

[mytarmailS]

Aleksey Nikolayev #:

Obrigado, vou pensar em como vinculá-lo às minhas tarefas.

Se você tiver alguma dúvida, por favor, pergunte. Gastei muito tempo com esta abordagem, por isso estou mais ou menos a par, na verdade acho que esta abordagem é a mais promissora.

[Mikhail Mishanin]

Uma abordagem ou ambas?

https://habr.com/ru/post/661457/

[Uladzimir Izerski]

Mikhail Mishanin #:

Uma abordagem ou ambas?

https://habr.com/ru/post/661457/

É raro ver uma tal revelação. Mas é a abordagem certa para o mercado.

[Aleksey Nikolayev]

Mikhail Mishanin #:

Uma abordagem ou ambas?

https://habr.com/ru/post/661457/

A meu ver, uma combinação harmoniosa de ambas as abordagens, levando em conta as especificidades de nossos objetivos. Sinais devem "pegar" a "física" do mercado, e modelos devem ser construídos para aumentar os lucros (ao invés da probabilidade de estar certo, por exemplo)