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

Nuovo commento
 
mytarmailS #:

Credo che stia confondendo FF con la superficie di ottimizzazione.

Non so più cosa pensa la gente, è come una specie di botta e risposta.
Ed è tutto inutile in termini di ricerca di modelli o di valutazione della robustezza.
 
Andrew, per esempio, non ha mai avuto una normale TC, ma crede così piamente di essere nel giusto da 20 anni e di fare qualcosa di veramente significativo.
E tutte queste argomentazioni sono buone come cataplasmi morti
 
fxsaber #:

C'è una certa furbizia in questo. I link sono solo per assicurarsi che si aprano. Nessuno che sia "interessato" li approfondirà. Nessuno leggerà gli articoli masticati di Andrei, tanto meno le opere di natura accademica.


Qualcuno ha visto questo TOP di facile comprensione con la possibilità di calcolare il ranking del proprio algoritmo di ottimizzazione?

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


Questi sono metodi di ottimizzazione basati sul gradiente per i neuroni,

e stiamo parlando di metodi di ottimizzazione globalesenza gradiente,

Andiamo, Saber.

Si tratta dell'ABC.

Di cui, tra l'altro, il tuo esperto locale di ottimizzazione non ha parlato nei suoi articoli (perché lui stesso è una quercia in AO).

 
Aleksey Nikolayev #:

Leggete questo, in particolare la sezione "Funzione di perdita = metrica di qualità". È difficile scrivere in modo più chiaro.

Non è stato possibile aprirlo, siamo un po' bloccati(

Aleksey Nikolayev #:
 Questo porta a un numero potenzialmente illimitato di parametri, poiché gli spazi di funzioni sono infinitamente dimensionali. In pratica, questo porta alla necessità di controllare il numero di parametri in qualche modo: per gli alberi, ad esempio, si tratta della potatura delle foglie.

Ad esempio, le foreste AMO, i boost sono costituiti da primitive, regole.


Possiamo creare una grammatica Beckus Naur delle regole di cui abbiamo bisogno.

in questo modo.

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

dietro ogni regola c'è un codice/stringa/genotipo.

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

A sinistra c'è il genotipo, a destra c'è la regola che viene generata, questo genotipo può essere cercato con l'aiuto di AO.

La somma delle regole è la stessa spinta o foresta...

È una specie di no-brainer.


Ecco il codice che implementa il tutto

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

Documentazione del pacchetto

Quindi non vedo alcun ostacolo per implementare il mio AMO puramente sull'ottimizzazione e sulla grammatica.


E abbiamo le mani libere su tutti i fronti, qualsiasi funzione, trasformazione, qualsiasi dato, in generale, qualsiasi cosa può essere implementata.



Lo stesso Forrest, nessuna differenza.

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 #:
Non è stato possibile aprirlo, siamo un po' bloccati(

Siamo bloccati spesso, in qualche modo ci adattiamo.

mytarmailS #:
Beh, per esempio le foreste AMO, i boost sono costituiti da primitive, regole.

Non ho affermato che l'assenza di un insieme fisso di parametri renda impossibile l'apprendimento (l'ottimizzazione). Parlavo solo di differenze significative rispetto all'ottimizzazione convenzionale con un insieme fisso di parametri. Se non mi credete, potete provare a implementare alberi o grammatiche in MT5 (dove l'ottimizzatore lavora per un insieme fisso). Non è assolutamente impossibile, ma è estremamente scomodo.

 
Aleksey Nikolayev #:

Non ho affermato che l'assenza di un insieme fisso di parametri renda impossibile l'apprendimento (ottimizzazione). Parlavo solo di differenze significative rispetto all'ottimizzazione convenzionale con un insieme fisso di parametri. Se non mi credete, potete provare a implementare alberi o grammatiche in MT5 (dove l'ottimizzatore lavora per un insieme fisso). Non è assolutamente impossibile, ma è estremamente scomodo.

Il linguaggio MQL5 consente di compensare l'assenza di caratteristiche standard del tester e dell'ottimizzatore. Quando è necessario un insieme dinamico di parametri, è possibile scrivere un ottimizzatore esterno per il modello in MQL5.

 
Andrey Dik #:

Il linguaggio MQL5 consente di compensare la mancanza di caratteristiche standard del tester e dell'ottimizzatore. Quando è necessario un insieme dinamico di parametri, è possibile scrivere un ottimizzatore esterno per il modello in MQL5.

È obbligatorio scrivere il gradient bousting in mql5 per diventare il creatore della bicicletta più angusta.
 

Uno studente pone delle domande a un'intelligenza artificiale.

Domanda: Come ti chiami?

Risposta: Vasya. Vai all'inferno.

Domanda: Che cosa significa andare all'inferno?

Risposta: È la risposta alla tua seconda domanda Vasya.

P.Z.

La domanda scuote il sistema neurale.

 
Aleksey Nikolayev #:
È obbligatorio scrivere il gradient bousting in mql5 per diventare il creatore della bicicletta più schifosa.

E qual è la differenza fondamentale tra il bousting in mql5 e quello scritto in qualsiasi altro linguaggio? mql5 è veloce come C# e quasi come C++. La sintassi non è molto diversa da questi linguaggi. Per le esigenze del MO, di recente sono state aggiunte molte funzioni integrate nel linguaggio.
Un tester standard è comodo come ambiente di trading pronto per l'uso, ma tutto ciò che riguarda il MO e l'ottimizzazione può essere implementato senza di esso, se qualcuno è stretto in esso.
Non ci sono limitazioni fondamentali nella MT5.
 
Andrey Dik #:

E qual è la differenza sostanziale tra il bounce in mql5 e il bounce scritto in qualsiasi altro linguaggio? mql5 è veloce come C# e quasi come C++. La sintassi non è molto diversa da questi linguaggi. Per le esigenze del MO, di recente sono state aggiunte molte funzioni integrate nel linguaggio.
Il tester standard è comodo come ambiente di trading pronto per l'uso, ma tutto ciò che riguarda il MO e l'ottimizzazione può essere implementato senza di esso, se qualcuno è stretto in esso.
Non ci sono limitazioni fondamentali nella MT5.
Quali meccanismi di parallelizzazione dei calcoli sulla CPU in mql5 conoscete?
1...337633773378337933803381338233833384338533863387338833893390...3399
Nuovo commento