Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 2633

[Andrey Khatimlianskii]

Maxim Dmitrievsky #:

Descargue el bot del mercado, ejecútelo en el probador de MT5, luego hay una opción para guardar el informe con todas las operaciones y otra información

Puede automatizar, incluyendo la ejecución de la prueba y la carga de las operaciones en csv -https://www.mql5.com/ru/code/26132

[Maxim Dmitrievsky]

mytarmailS #:

Se ha puesto en marcha una estrategia de oro del mercado ))

Curva capital en mi probador.

lo lanzó en tslab para obtener una mejor visión

Parece que es un buen partido.

He mirado los oficios.

Utilicé mi comerciante de la mano y yo no entiendo su algoritmo de negociación.

Forrest ciertamente no pudo identificar nada, pero fue interesante e informativo )))

Así que hay que leer qué marco temporal y enseñar dos modelos. Uno para las operaciones, el otro para el tiempo. O multiclase. Mira la descripción del bot, tal vez esté mal y no encaje

[Maxim Dmitrievsky]

Andrey Khatimlianskii #:

Puede automatizarse, incluyendo la ejecución de una prueba y la carga de transacciones en csv -https://www.mql5.com/ru/code/26132

Sí, gracias.

[Maxim Dmitrievsky]

Dmytryi Voitukhov #:

Podría ser útil... Tengo un many-to-many sin recurrencia. Y sin capas de convolución. Y elegí este modelo después de analizar el mecanismo neuronal. Estamos buscando un denominador común aquí, ¿no? Discute.

No estoy seguro de lo que tengo que argumentar.

[mytarmailS]

Aleksey Nikolayev #:

Gracias, voy a echar un vistazo.

Aun así, con nosotros, el orden es importante. Siempre es posible, por ejemplo, obtener SB barajando los incrementos al azar.

También he recordado que una vez escribiste aquí sobre la minería de patrones secuenciales y el problema de la alineación de secuencias que se plantea allí. También parece ser uno de los métodos para resolver el problema. Aunque la pertenencia de las secuencias a una misma clase no significa necesariamente que sean similares.

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

datos

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"

ejecutamos la función y buscamos las secuencias que conducen a nuestras 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

La función es "sucia", pero funciona, cambie las rutas en la función para sus propias necesidades e instale los paquetes correctos.

Pero debes saber que los algoritmos que buscan este tipo de "secuencias dispersas" son muy voraces, hay una búsqueda enorme, a pesar de que el propio algoritmo hace una búsqueda eficiente y está escrito en C++

[Aleksey Nikolayev]

mytarmailS #:

datos

ejecutar la función y buscar secuencias que lleven a nuestras etiquetas

La función es "sucia", la escribí para mí, pero funciona, cambia las rutas en la función por ti mismo e instala los paquetes correctos.

Pero debes saber que los algoritmos que buscan este tipo de "secuencias dispersas" son muy voraces, hay una búsqueda enorme, a pesar de que el propio algoritmo hace una búsqueda eficiente y está escrito en C++

Gracias, pensaré en cómo añadirlo a mis problemas.

[mytarmailS]

Aleksey Nikolayev #:

Gracias, pensaré en cómo adjuntarlo a mis tareas.

Si tiene alguna duda, no dude en preguntar. He dedicado mucho tiempo a este enfoque, así que estoy más o menos al tanto, de hecho creo que este enfoque es el más prometedor

[Mikhail Mishanin]

¿Un enfoque o ambos?

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

[Aleksey Nikolayev]

Mikhail Mishanin #:

¿Un enfoque o ambos?

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

En mi opinión, una combinación armoniosa de ambos enfoques, teniendo en cuenta las particularidades de nuestros objetivos. Las señales deben "captar" la "física" del mercado, y los modelos deben construirse para aumentar los beneficios (en lugar de la probabilidad de acertar, por ejemplo)

[Aleksey Nikolayev]

Un poco más de cuasi-filosofía. El compromiso entre el sesgo y la varianza siempre limitará la complejidad del modelo. Por lo tanto, nunca se puede estar seguro de que el modelo funcione bien con todo el conjunto de predictores. En consecuencia, se plantea la tarea de determinar un subconjunto de trabajo de este modelo. Si he entendido bien, esto es exactamente lo que Maxim escribió recientemente (sobre dos modelos). Está en consonancia con la vieja idea de que "no hay que intentar estar en el mercado todo el tiempo".

Sería bueno intentar combinar todo esto en un solo modelo. Por ejemplo, esta idea (Aleksey Vyazmikin tenía una ligeramente parecida): dividimos cada predictor en segmentos, lo que da un desglose del conjunto de predictores en cubos multidimensionales. A continuación, de todos estos cubos elegimos un conjunto de cubos adecuados. Con una gran dimensionalidad este problema será combinatoriamente intratable, pero podemos hacerlo por analogía con el bosque aleatorio: elegir aleatoriamente conjuntos de predictores de baja dimensión. La segmentación inicial para cada predictor puede hacerse dividiendo el patrimonio (cuando las transacciones se ordenan por un determinado predictor y no por tiempo) en trozos monótonos.

Suplementar todo con la validación cruzada (hacia adelante) y todas las otras cosas que se supone) Probablemente, ni siquiera será bastante sin sentido) Bueno, o alguien ha hecho algo así antes.