L'apprendimento automatico nel trading: teoria, modelli, pratica e algo-trading - pagina 2633

[Andrey Khatimlianskii]

Maxim Dmitrievsky #:

Scarica il bot dal mercato, eseguilo nel tester MT5, poi c'è un'opzione per salvare il rapporto con tutte le operazioni e altre informazioni

È possibile automatizzare, compresa l'esecuzione del test e il caricamento delle transazioni in csv -https://www.mql5.com/ru/code/26132

[Maxim Dmitrievsky]

mytarmailS #:

Scaturita una strategia d'oro dal mercato ))

Curva maiuscola nel mio tester.

l'ha gettato in tslab per avere un aspetto migliore

Sembra che sia un buon abbinamento.

Ho guardato gli scambi.

L'ho guardato come se fosse un trader manuale con una seduta estremamente lunga e un vago algoritmo di trading...

Forrest certamente non ha potuto identificare nulla, ma è stato interessante e informativo )))

Quindi è necessario leggere quale periodo e insegnare due modelli. Uno per gli scambi, l'altro per i tempi. O multiclasse. Guarda la descrizione del bot, forse è brutto e non si adatta

[Maxim Dmitrievsky]

Andrey Khatimlianskii #:

Può essere automatizzato, compresa l'esecuzione di un test e il caricamento delle transazioni in csv -https://www.mql5.com/ru/code/26132

Sì, grazie

[Maxim Dmitrievsky]

Dmytryi Voitukhov #:

Potrebbe essere utile... Ho un molti a molti senza ricorrenza. E nessun livello di convoluzione. E ho scelto questo modello dopo aver analizzato il meccanismo neuronale. Stiamo cercando un denominatore comune, vero? Argomentare.

Non sono sicuro di cosa devo argomentare.

[mytarmailS]

Aleksey Nikolayev #:

Grazie, darò un'occhiata.

Eppure, con noi, l'ordine è importante. È sempre possibile, per esempio, ottenere SB mescolando gli incrementi in modo casuale.

Mi sono anche ricordato che una volta hai scritto qui sull'estrazione di modelli sequenziali e sul problema dell'allineamento delle sequenze. Sembra anche essere uno dei metodi per risolvere il problema. Anche se l'appartenenza delle sequenze a una classe non significa necessariamente che siano simili.

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)}

dati

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"

eseguiamo la funzione e cerchiamo le sequenze che portano ai nostri segni

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

La funzione è "sporca", ma funziona, cambiate i percorsi nella funzione per le vostre esigenze e installate i pacchetti corretti.

Ma dovete sapere che gli algoritmi che cercano tali "sequenze sparse" di questo tipo sono molto voraci, c'è una ricerca enorme, nonostante il fatto che l'algoritmo stesso faccia una ricerca efficiente e sia scritto in C++

[Aleksey Nikolayev]

mytarmailS #:

dati

eseguire la funzione e cercare le sequenze che portano alle nostre etichette

La funzione è "sporca", l'ho scritta per me stesso, ma funziona, cambia i percorsi nella funzione per te e installa i pacchetti corretti.

Ma dovete sapere che gli algoritmi che cercano tali "sequenze sparse" di questo tipo sono molto voraci, c'è una ricerca enorme, nonostante il fatto che l'algoritmo stesso faccia una ricerca efficiente e sia scritto in C++

Grazie, penserò a come aggiungerlo ai miei problemi.

[mytarmailS]

Aleksey Nikolayev #:

Grazie, penserò a come allegarlo ai miei compiti.

Se avete domande, chiedete pure. Ho passato molto tempo su questo approccio, quindi sono più o meno informato, infatti penso che questo approccio sia il più promettente

[Mikhail Mishanin]

Un approccio o entrambi?

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

[Uladzimir Izerski]

Mikhail Mishanin #:

Un approccio o entrambi?

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

È raro vedere una tale rivelazione. Ma è il giusto approccio al mercato.

[Aleksey Nikolayev]

Mikhail Mishanin #:

Un approccio o entrambi?

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

A mio parere, una combinazione armoniosa di entrambi gli approcci, tenendo conto delle specificità dei nostri obiettivi. I segnali dovrebbero "catturare" la "fisica" del mercato, e i modelli dovrebbero essere costruiti per aumentare i profitti (piuttosto che la probabilità di avere ragione, per esempio)