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

新评论
 
mytarmailS #:

我觉得他把 FF 和优化表面混为一谈了。

我已经不知道大家在想什么了，这就像是某种戏谑。
而且，就寻找模式或评估稳健性而言，这一切都毫无意义
 
比如安德鲁，他从未有过正常的 TC，但他如此虔诚地相信自己 20 年来一直是正确的，他在做真正有意义的事情。
而所有这些论点就像死膏药一样好用
 
fxsaber #:

有一种狡猾的感觉。链接只是为了确保它们能打开。没有 "有兴趣 "的人会深入研究。没有人会去读安德烈那些被嚼烂了的文章，更不用说学术著作了。


有没有人见过这个通俗易懂的 TOP，能够计算出自己的优化算法排名？

https://habr.com/ru/users/belyalova/publications/articles/


这些都是基于梯度的神经元优化方法、

而我们谈论的是无梯度 全局 优化方法、

拜托，Saber。

这是 ABC。

顺便说一句，你们当地的优化专家在他的文章中对此只字未提（因为他自己就是 AO 中的一棵橡树）。

 
Aleksey Nikolayev #:

请阅读这篇文章，尤其是 "损失函数 != 质量指标 "部分。我几乎无法写得更清楚了。

打不开，有点卡住了(

Aleksey Nikolayev#:
 由于函数空间是无限维的，这可能导致参数数量无限。在实践中，这导致需要以某种方式控制参数数量--例如，对于树来说，这就是修剪树叶。

例如，AMO forrests、boosts 由基元、规则组成。


我们可以根据所需的规则创建贝库斯-诺尔（Beckus Naur）语法。

就像这样

grammarDef
<ex3> ::= <ex2> | <ex2> & <ex2> | <ex2> & <ex3>
<ex2> ::= <ex1> | <com>(<ex1>, <ex1>)
<ex1> ::= <op>(<var>, <var>)
<com> ::= "&" | "|"
<op>  ::= ">=" | "<=" | "==" | "!="
<var> ::= x1 | x2 | x3 | x4

每条规则后面都有一个代码/字符串/基因型。

2 3 1 3 2 4 3 2 3 1 4 4 1 2 1 4 3 2 4 3 4 1 3 4 3 1 2 1 1 3 2 4 1 4 2 4 3 3 1 4 3 2 3  ->  (x1 == x4 | x2 != x1) & (x4 >= x3 & x1 != x2) & (x3 <= x2 & x3 != x1) 
1 1 4 4 1 4 1 4 2 3 1 4 1 1 1 3 1 4 2 3 4 1 1 3 4 3 2 4 1 4 2 3 4 3 3 2 3 4 2 2 4 4 3  ->  x1 <= x2 & x4 == x2 & x2 <= x4 
2 4 1 4 1 1 1 2 1 4 4 1 2 1 3 1 2 3 3 3 3 4 4 2 2 3 1 3 4 2 2 1 2 4 2 1 4 4 3 3 1 4 3  ->  x2 >= x2 & x1 >= x2 & x2 != x3 
4 3 1 3 2 4 2 2 3 4 4 1 1 2 2 1 3 2 4 3 4 3 3 1 3 1 3 2 2 2 4 4 2 3 2 1 4 1 3 1 3 2 4  ->  (x1 == x3 | x1 != x1) & (x2 == x4 | x4 >= x1) 
1 3 3 1 4 2 2 3 4 3 3 4 4 2 2 4 3 1 4 2 1 1 3 4 2 3 1 2 3 1 1 1 3 3 2 2 2 2 2 3 3 1 2  ->  (x3 >= x3 | x4 >= x4) & x3 == x1 
2 1 2 1 3 3 1 2 3 3 2 3 3 3 2 3 4 4 4 3 4 3 2 2 3 1 4 3 4 2 4 3 4 1 2 3 1 2 1 3 1 4 3  ->  x4 != x2 & x4 != x3 & (x1 != x1 | x1 != x4) 
3 3 1 1 3 3 3 2 4 2 2 3 1 2 2 3 2 4 1 4 3 4 4 2 2 4 1 2 2 4 3 4 2 2 3 4 3 4 4 3 4 4 2  ->  x4 != x4 | x3 >= x3 
3 2 1 1 3 4 2 3 2 2 2 4 3 2 3 4 2 2 4 4 1 1 3 1 2 3 2 4 1 2 1 2 1 2 1 4 3 2 4 1 1 4 2  ->  x4 <= x1 
4 2 3 2 4 4 3 3 3 4 1 4 3 3 3 2 4 3 1 3 4 4 1 4 4 2 1 2 3 1 3 3 4 2 4 1 4 2 3 4 3 4 3  ->  x1 == x1 & (x2 >= x1 | x4 != x3) 
3 2 2 1 2 3 2 4 3 3 4 2 4 4 2 4 3 4 2 2 1 1 2 2 1 3 1 4 3 4 3 2 4 4 3 2 2 2 2 2 3 1 1  ->  x3 <= x4

左边是基因型，右边是生成的规则，这个基因型可以借助 AO 进行搜索。

规则的总和是相同的提升或森林......

这就不难理解了。


下面是实现这一切的代码

library(gramEvol)
grammarDef <- CreateGrammar(list(
  ex3 = grule(ex2, ex2 & ex2, ex2 & ex3),
  ex2 = grule(ex1, com(ex1, ex1)),
  ex1 = grule( op(var, var) ),
  com = grule("&","|"),
  op = grule(">=","<=","==","!="),
  var = grule(x1,x2,x3,x4)))


for(i in 1:10){
  genotype <- sample(1:4,size = 43,replace = T)
  rule <- as.character(GrammarMap(genotype, grammarDef))
  cat(as.character(genotype), " -> ", rule, "\n")
}

软件包文档

因此，我认为纯粹依靠优化和语法来实现 AMO 没有任何障碍。


而且我们在所有方面都是自由的，任何函数、转换、任何数据，总之，任何东西都可以实现。



同样是 Forrest，没有任何区别。

X <- iris[,1:(ncol(iris)-1)]
target <- iris[,"Species"] 


library(inTrees)
library(RRF)

target |> 
as.factor() |> 
RRF(x = X,ntree=100) |> 
RF2List() |> 
extractRules(X = X) 






697 rules (length<=6) were extracted from the first 100 trees.
       condition                                                                        
  [1,] "X[,4]<=0.8"                                                                     
  [2,] "X[,4]>0.8 & X[,4]<=1.65 & X[,4]<=1.45"                                          
  [3,] "X[,3]<=4.95 & X[,4]>0.8 & X[,4]<=1.65 & X[,4]>1.45 & X[,4]<=1.55"               
  [4,] "X[,3]>4.95 & X[,4]>0.8 & X[,4]<=1.65 & X[,4]>1.45 & X[,4]<=1.55"                
  [5,] "X[,4]>0.8 & X[,4]<=1.65 & X[,4]>1.45 & X[,4]>1.55"                              
  [6,] "X[,3]<=4.75 & X[,4]>0.8 & X[,4]>1.65 & X[,4]<=1.85 & X[,4]<=1.75"               
  [7,] "X[,3]>4.75 & X[,4]>0.8 & X[,4]>1.65 & X[,4]<=1.85 & X[,4]<=1.75"                
  [8,] "X[,1]<=5.95 & X[,3]<=4.85 & X[,4]>0.8 & X[,4]>1.65 & X[,4]<=1.85 & X[,4]>1.75"  
  [9,] "X[,1]>5.95 & X[,3]<=4.85 & X[,4]>0.8 & X[,4]>1.65 & X[,4]<=1.85 & X[,4]>1.75"   
 [10,] "X[,3]>4.85 & X[,4]>0.8 & X[,4]>1.65 & X[,4]<=1.85 & X[,4]>1.75"                 
 [11,] "X[,4]>0.8 & X[,4]>1.65 & X[,4]>1.85"                                            
 [12,] "X[,4]<=0.8"                                                                     
 [13,] "X[,3]<=4.95 & X[,4]>0.8 & X[,4]<=1.55"                                          
 [14,] "X[,3]>4.95 & X[,4]>0.8 & X[,4]<=1.55"                                           
 [15,] "X[,1]<=5.45 & X[,4]>0.8 & X[,4]>1.55 & X[,4]<=1.75"                             
 [16,] "X[,1]>5.45 & X[,3]<=5.45 & X[,4]>0.8 & X[,4]>1.55 & X[,4]<=1.75"                
 [17,] "X[,1]>5.45 & X[,3]>5.45 & X[,4]>0.8 & X[,4]>1.55 & X[,4]<=1.75"                 
 [18,] "X[,1]<=5.95 & X[,3]<=4.9 & X[,4]>0.8 & X[,4]>1.55 & X[,4]>1.75"                 
 [19,] "X[,1]>5.95 & X[,3]<=4.9 & X[,4]>0.8 & X[,4]>1.55 & X[,4]>1.75"                  
 [20,] "X[,3]>4.9 & X[,4]>0.8 & X[,4]>1.55 & X[,4]>1.75"                                
 [21,] "X[,4]<=0.8"                                                                     
 [22,] "X[,3]<=4.85 & X[,4]>0.8 & X[,4]<=1.7"                                           
 [23,] "X[,1]<=5.95 & X[,3]<=4.85 & X[,4]>0.8 & X[,4]>1.7"                              
 [24,] "X[,1]>5.95 & X[,3]<=4.85 & X[,4]>0.8 & X[,4]>1.7"                               
 [25,] "X[,1]<=6.6 & X[,3]>4.85 & X[,4]>0.8 & X[,4]<=1.65"                              
 [26,] "X[,1]>6.6 & X[,3]>4.85 & X[,4]>0.8 & X[,4]<=1.65"                               
 [27,] "X[,3]>4.85 & X[,4]>0.8 & X[,4]>1.65"                                            
 [28,] "X[,3]<=2.45"                                                                    
 [29,] "X[,3]>2.45 & X[,3]<=5.35 & X[,4]<=1.75"                                         
 [30,] "X[,3]>2.45 & X[,3]>5.35 & X[,4]<=1.75"                                          
 [31,] "X[,1]<=5.95 & X[,3]>2.45 & X[,3]<=4.85 & X[,4]>1.75"                            
 [32,] "X[,1]>5.95 & X[,3]>2.45 & X[,3]<=4.85 & X[,4]>1.75"                             
 [33,] "X[,3]>2.45 & X[,3]>4.85 & X[,4]>1.75"                                           
 [34,] "X[,3]<=2.45"           
...
..
..
..
.
.
.
 
mytarmailS #:
打不开，我们有点被挡住了（......）。

我们经常受阻，但我们能适应。

mytarmailS#:
例如，AMO 森林、助推器都是由基元、规则组成的。

我并没有说没有固定的参数集就不可能进行学习（优化）。我只是在谈论与传统的固定参数优化的显著区别。如果您不相信我，可以尝试在 MT5 中实现树或语法（优化器在固定参数集中工作）。这并非绝对不可能，但却非常不方便。

 
Aleksey Nikolayev #:

我并没有说没有固定参数集就不可能进行学习（优化）。我只是说与传统的固定参数优化有很大不同。如果你不相信我，可以尝试在 MT5 中实现树或语法（优化器在固定参数集下工作）。这并非绝对不可能，但却非常不方便。

MQL5 语言可以弥补测试器和优化器标准功能的缺失。如果需要动态参数集，您可以在 MQL5 中为模型编写外部优化器。

 
Andrey Dik #:

MQL5 语言可以弥补测试器和优化器标准功能的不足。如果需要动态参数集，您可以在 MQL5 中为模型编写外部优化器。

要成为最拥挤自行车的创造者，就必须用 MQL5 编写梯度缓冲。
 

一名学生向人工智能提问。

问： 你叫什么名字？

回答：瓦夏。下地狱吧

问题：什么是 "下地狱"？

回答：它就是你第二个问题的答案，瓦夏。

P.Z.

这个问题震撼了神经系统。

 
Aleksey Nikolayev #:
要想成为最蹩脚的自行车的创造者，就必须用 mql5 来编写渐变缓冲。

那么，用 mql5 编写的渐变和用其他语言编写的渐变有什么本质区别呢？mql5 和 C# 一样快，几乎和 C++ 一样快。语法与这些语言没有太大区别。为了满足 MO 的需要，最近增加了许多内置语言功能。
标准测试器作为现成的交易环境非常方便，但如果有人对其感到乏味，也可以在没有测试器的情况下实现与 MO 和优化有关的所有功能。
MT5 没有基本限制。
 
Andrey Dik #:

用 mql5 编写的 Bousting 与用其他语言编写的 Bousting 有什么本质区别？mql5 和 C# 一样快，几乎和 C++ 一样快。语法与这些语言差别不大。为了满足 MO 的需要，最近增加了许多内置语言功能。
标准测试器作为现成的交易环境非常方便，但如果有人对它感到乏味，没有它也可以实现与 MO 和优化有关的所有功能。
MT5 没有基本限制。
您知道 mql5 中 CPU 上的并行计算机制是什么？
1...337633773378337933803381338233833384338533863387338833893390...3399
新评论