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

Novo comentário
 
mytarmailS #:

Acho que ele está confundindo FF com superfície de otimização.

Não sei mais o que as pessoas pensam, é como uma espécie de brincadeira.
E tudo isso é inútil em termos de encontrar padrões ou avaliar a robustez
 
Andrew, por exemplo, nunca teve um TC normal, mas acredita piamente que está certo há 20 anos e que está fazendo algo realmente significativo.
E todos esses argumentos são tão bons quanto cataplasmas mortos
 
fxsaber #:

Há uma certa astúcia nisso. Os links são apenas para garantir que sejam abertos. Ninguém que esteja "interessado" irá se aprofundar neles. Ninguém lerá os artigos mastigados de Andrei, muito menos trabalhos de natureza acadêmica.


Alguém já viu esse TOP fácil de entender com a capacidade de calcular a classificação de seu próprio algoritmo de otimização?

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


Esses são métodos de otimização baseados em gradiente para neurônios,

e estamos falando de métodos de otimização globalsem gradiente,

Vamos lá, Saber.

São os ABCs.

A propósito, seu especialista local em otimizações não falou nada sobre isso em seus artigos (porque ele mesmo é um carvalho em AO).

 
Aleksey Nikolayev #:

Leia isto, especialmente a seção "Função de perda != métrica de qualidade". Não consigo escrever de forma mais clara.

Não foi possível abri-lo, estamos um pouco bloqueados(

Aleksey Nikolayev #:
 Isso leva a um número potencialmente ilimitado de parâmetros, já que os espaços de função são de dimensão infinita. Na prática, isso leva à necessidade de controlar o número de parâmetros de alguma forma - no caso das árvores, é a poda das folhas, por exemplo.

Por exemplo, as florestas do AMO e os boosts consistem em primitivas, regras.


Podemos criar uma gramática Beckus Naur com as regras de que precisamos.

Assim.

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

Por trás de cada regra, há um código/corda/genótipo.

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

À esquerda está o genótipo, à direita está a regra gerada; esse genótipo pode ser pesquisado com a ajuda do AO.

A soma das regras é o mesmo impulso ou floresta...

É algo simples.


Aqui está o código que implementa tudo isso

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

Documentação do pacote

Portanto, não vejo nenhum obstáculo para implementar meu AMO puramente em otimização e gramática.


E nossas mãos estão livres em todas as frentes, quaisquer funções, transformações, quaisquer dados, em geral, qualquer coisa pode ser implementada.



O mesmo Forrest, sem diferença.

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 #:
Não foi possível abri-lo, estamos um pouco bloqueados(

Somos muito bloqueados, mas de alguma forma nos adaptamos.

mytarmailS #:
Bem, por exemplo, as florestas AMO e os reforços consistem em primitivos, regras.

Eu não afirmei que a ausência de um conjunto fixo de parâmetros impossibilita o aprendizado (otimização). Eu estava falando apenas de diferenças significativas em relação à otimização convencional com um conjunto fixo de parâmetros. Se você não acredita em mim, pode tentar implementar árvores ou gramáticas no MT5 (onde o otimizador trabalha com um conjunto fixo). Não é que seja absolutamente impossível, mas é extremamente inconveniente.

 
Aleksey Nikolayev #:

Eu não afirmei que a ausência de um conjunto fixo de parâmetros torna o aprendizado (otimização) impossível. Eu estava falando apenas de diferenças significativas em relação à otimização convencional com um conjunto fixo de parâmetros. Se você não acredita em mim, pode tentar implementar árvores ou gramáticas no MT5 (onde o otimizador trabalha com um conjunto fixo). Não é que seja absolutamente impossível, mas é extremamente inconveniente.

A linguagem MQL5 permite que você compense a ausência de quaisquer recursos padrão do testador e do otimizador. Quando for necessário um conjunto dinâmico de parâmetros, você poderá escrever um otimizador externo para o modelo em MQL5.

 
Andrey Dik #:

A linguagem MQL5 permite que você compense a falta de recursos padrão do testador e do otimizador. Quando for necessário um conjunto dinâmico de parâmetros, você poderá escrever um otimizador externo para o modelo em MQL5.

É obrigatório escrever o gradient bousting em mql5 para se tornar o criador da bicicleta mais apertada.
 

Um aluno faz perguntas a uma inteligência artificial.

Pergunta: Qual é o seu nome?

Resposta: Vasya. Ir para o inferno.

Pergunta: O que é ir para o inferno?

Resposta: É a resposta para sua segunda pergunta, Vasya.

P.Z.

A pergunta choca o sistema neural.

 
Aleksey Nikolayev #:
É obrigatório escrever gradient bousting em mql5 para se tornar o criador da bicicleta mais ruim.

E qual é a diferença fundamental entre o bousting em mql5 e o escrito em qualquer outra linguagem? O mql5 é tão rápido quanto o C# e quase tão rápido quanto o C++. A sintaxe não é muito diferente dessas linguagens. Para as necessidades de MO, muitos recursos de linguagem incorporados estão sendo adicionados recentemente.
Um testador padrão é conveniente como um ambiente de negociação pronto, mas tudo o que se refere a MO e otimização pode ser implementado sem ele, se alguém estiver limitado a ele.
Não há limitações fundamentais no MT5.
 
Andrey Dik #:

E qual é a diferença fundamental entre o busting em mql5 e o busting escrito em qualquer outra linguagem? O mql5 é tão rápido quanto o C# e quase tão rápido quanto o C++. A sintaxe não é muito diferente dessas linguagens. Para atender às necessidades do MO, muitos recursos incorporados à linguagem estão sendo adicionados recentemente.
O testador padrão é conveniente como um ambiente de negociação pronto, mas tudo o que diz respeito ao MO e à otimização pode ser implementado sem ele, se alguém não tiver muito espaço para isso.
Não há limitações fundamentais no MT5.
Quais mecanismos de paralelização de cálculos na CPU no mql5 você conhece?
1...337633773378337933803381338233833384338533863387338833893390...3399
Novo comentário