交易中的机器学习：理论、模型、实践和算法交易 - 页 2633

[Andrey Khatimlianskii]

Maxim Dmitrievsky #:

从市场上下载机器人，在MT5测试器中运行，然后有一个选项可以保存所有交易和其他信息的报告。

你可以实现自动化，包括运行测试和上传交易到csv -https://www.mql5.com/ru/code/26132

[Maxim Dmitrievsky]

mytarmailS #:

从市场上引发了一个黄金战略 ))

我的测试器中的资本曲线。

把它扔到tslab中以获得更好的外观

看起来是个不错的搭配。

我看了看这些交易。

我把它看成是一个手动交易员，坐的时间极长，交易算法模糊不清......

福雷斯特当然无法识别任何东西，但它很有趣，而且信息量很大 ))

因此，你需要读懂哪个时间段，并教授两种模式。一个是交易，另一个是时机。或多类。看一下机器人的描述，也许它是坏的，不适合。

[Maxim Dmitrievsky]

Andrey Khatimlianskii #:

可以自动化，包括运行测试和上传交易到csv -https://www.mql5.com/ru/code/26132

是的，谢谢

[Maxim Dmitrievsky]

Dmytryi Voitukhov #:

可能是有用的...我有一个没有复发的多对多。而且没有卷积层。而我在解析了神经元机制后选择了这个模型。我们在这里寻找一个共同点，不是吗？争 论。

我不知道我需要论证什么。

[mytarmailS]

Aleksey Nikolayev #:

谢谢，我会看看的。

不过，对我们来说，秩序确实很重要。例如，总是有可能通过随机洗刷增量来获得SB。

我还记得，你曾经在这里写过关于序列模式的挖掘和那里产生的序列排列问题。这似乎也是解决问题的方法之一。虽然序列属于一个类别，但不一定意味着它们是相似的。

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

数据

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"

我们运行该函数并搜索导致我们的标记的序列

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

这个函数很 "脏"，但它可以工作，根据你自己的需要改变函数中的路径，并安装正确的软件包。

但是你应该知道，寻找这种类型的 "稀疏序列 "的算法是非常贪婪的，有一个巨大的搜索，尽管该算法本身做了一个有效的搜索，并且是用C++写的。

[Aleksey Nikolayev]

mytarmailS #:

数据

运行函数并寻找导致我们的标签的序列

这个函数是 "肮脏的"，我为自己写的，但它是有效的，为自己改变函数中的路径，并安装正确的软件包。

但是你应该知道，寻找这种类型的 "稀疏序列 "的算法是非常贪婪的，有一个巨大的搜索，尽管该算法本身做了一个有效的搜索，并且是用C++写的。

谢谢，我会考虑如何把它加入我的问题中。

[mytarmailS]

Aleksey Nikolayev #:

谢谢，我会考虑如何把它附在我的任务上。

如果你有任何问题，请提出。我在这个方法上花了很多时间，所以我或多或少知道一些，事实上我认为这个方法是最有希望的。

[Mikhail Mishanin]

一种方法还是两种都有？

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

[Uladzimir Izerski]

Mikhail Mishanin #:

一种方法还是两种都有？

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

很少看到这样的启示。但这是对市场的正确做法。

[Aleksey Nikolayev]

Mikhail Mishanin #:

一种方法还是两种方法？

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

我认为，在考虑到我们目标的具体情况下，要把这两种方法和谐地结合起来。标志应该 "抓住 "市场的 "物理学"，建立模型应该是为了增加利润（而不是正确的概率，例如）