Maschinelles Lernen im Handel: Theorie, Modelle, Praxis und Algo-Trading - Seite 3383

Neuer Kommentar
 
mytarmailS #:

Ich glaube, er verwechselt FF mit Optimierungsflächen.

Ich weiß nicht mehr, was irgendjemand denkt, es ist wie eine Art Geplänkel.
Und es ist alles sinnlos, wenn es darum geht, Muster zu finden oder die Robustheit zu bewerten.
 
Andrew zum Beispiel hatte noch nie eine normale TK, aber er glaubt so fromm, dass er seit 20 Jahren Recht hat und etwas wirklich Sinnvolles tut.
Und all diese Argumente sind so gut wie tote Säcke
 
fxsaber #:

Das hat eine gewisse Verschlagenheit. Die Links sind nur dazu da, um sicherzustellen, dass sie sich öffnen. Niemand, der "interessiert" ist, wird sich mit ihnen befassen. Niemand wird Andrei's zerkaute Artikel lesen, geschweige denn akademische Werke.


Hat jemand dieses leicht verständliche TOP mit der Möglichkeit, die Rangfolge seines eigenen Optimierungsalgorithmus zu berechnen, gesehen?

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


Dies sind gradientenbasierte Optimierungsmethoden für Neuronen ,

und wir reden hier über gradientenfreie globale Optimierungsmethoden,

Komm schon, Saber.

Das sind die ABCs.

Worüber übrigens Ihr lokaler Experte für Optimierungen in seinen Artikeln nichts gesagt hat (weil er selbst eine Eiche in AO ist).

 
Aleksey Nikolayev #:

Lesen Sie dies, insbesondere den Abschnitt "Verlustfunktion != Qualitätsmetrik". Deutlicher kann ich kaum schreiben.

Konnte es nicht öffnen, wir sind ein bisschen blockiert(

Aleksey Nikolayev #:
 Dies führt zu einer potenziell unbegrenzten Anzahl von Parametern, da Funktionsräume unendlich-dimensional sind. In der Praxis führt dies dazu, dass die Anzahl der Parameter irgendwie kontrolliert werden muss - bei Bäumen zum Beispiel durch das Beschneiden der Blätter.

Zum Beispiel bestehen AMO-Wälder, Boosts aus Primitiven, Regeln.


Wir können eine Beckus-Naur-Grammatik der Regeln erstellen, die wir brauchen.

etwa so.

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

Hinter jeder Regel befindet sich ein Code/String/Genotyp.

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

Auf der linken Seite steht der Genotyp, auf der rechten Seite die generierte Regel, dieser Genotyp kann mit Hilfe von AO durchsucht werden.

Die Summe der Regeln ist der gleiche Boost oder Wald...

Es ist eine Art von no-brainer.


Hier ist der Code, der das Ganze implementiert

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

Dokumentation zum Paket

Ich sehe also keine Hindernisse, meine AMO rein auf Optimierung und Grammatik zu implementieren.


Und wir haben an allen Fronten die Hände frei, beliebige Funktionen, Transformationen, beliebige Daten, im Allgemeinen kann alles implementiert werden.



Derselbe Forrest, kein Unterschied.

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 #:
Konnte es nicht öffnen, wir sind ein bisschen blockiert(

Wir sind oft blockiert, irgendwie passen wir uns an.

mytarmailS #:
Nun, zum Beispiel AMO-Wälder, Boosts bestehen aus Primitiven, Regeln.

Ich habe nicht behauptet, dass das Fehlen eines festen Satzes von Parametern das Lernen (die Optimierung) unmöglich macht. Ich sprach nur von signifikanten Unterschieden zur konventionellen Optimierung mit einem festen Satz von Parametern. Wenn Sie mir nicht glauben, können Sie versuchen, Bäume oder Grammatiken in MT5 zu implementieren (wo der Optimierer mit einer festen Menge arbeitet). Es ist nicht so, dass es absolut unmöglich ist, aber es ist extrem umständlich.

 
Aleksey Nikolayev #:

Ich habe nicht behauptet, dass das Fehlen eines festen Satzes von Parametern das Lernen (die Optimierung) unmöglich macht. Ich sprach lediglich von signifikanten Unterschieden zur herkömmlichen Optimierung mit einem festen Satz von Parametern. Wenn Sie mir nicht glauben, können Sie versuchen, Bäume oder Grammatiken in MT5 zu implementieren (wo der Optimierer mit einer festen Menge arbeitet). Es ist nicht so, dass es absolut unmöglich ist, aber es ist extrem unbequem.

Die MQL5-Sprache ermöglicht es Ihnen, das Fehlen von Standardfunktionen des Testers und des Optimierers zu kompensieren. Wenn ein dynamischer Parametersatz erforderlich ist, können Sie einen externen Optimierer für das Modell in MQL5 schreiben.

 
Andrey Dik #:

Die MQL5-Sprache ermöglicht es Ihnen, das Fehlen von Standardfunktionen des Testers und des Optimierers auszugleichen. Wenn ein dynamischer Satz von Parametern erforderlich ist, können Sie einen externen Optimierer für das Modell in MQL5 schreiben.

Es ist obligatorisch, das Gradientenbusting in MQL5 zu schreiben, um der Schöpfer des engsten Fahrrads zu werden.
 

Ein Schüler stellt Fragen an eine künstliche Intelligenz.

Frage: Wie ist dein Name?

Antwort: Vasya. Fahr zur Hölle.

Frage: Was ist "Fahr zur Hölle"?

Antwort: Das ist die Antwort auf deine zweite Frage, Vasya.

P.Z..

Die Frage schockiert das neuronale System.

 
Aleksey Nikolayev #:
Es ist obligatorisch, Gradient Bousting in mql5 zu schreiben, um der Schöpfer des beschissensten Fahrrads zu werden.

Und was ist der grundlegende Unterschied zwischen Bousting in mql5 und in einer anderen Sprache geschrieben? mql5 ist so schnell wie C# und fast so schnell wie C++. Die Syntax ist nicht viel anders als bei diesen Sprachen. Für MO-Bedürfnisse wurden in letzter Zeit eine Menge eingebauter Sprachfunktionen hinzugefügt.
Ein Standard-Tester ist als fertige Handelsumgebung praktisch, aber alles, was MO und Optimierung betrifft, kann auch ohne ihn implementiert werden, wenn jemand darin verkrampft ist.
Es gibt keine grundsätzlichen Beschränkungen in MT5.
 
Andrey Dik #:

Und was ist der grundlegende Unterschied zwischen Bousting in mql5 und Bousting, das in einer anderen Sprache geschrieben wurde? mql5 ist so schnell wie C# und fast so schnell wie C++. Die Syntax unterscheidet sich nicht wesentlich von diesen Sprachen. Für MO-Bedürfnisse werden in letzter Zeit eine Menge eingebauter Sprachfunktionen hinzugefügt.
Der Standardtester ist als fertige Handelsumgebung praktisch, aber alles, was mit MO und Optimierung zu tun hat, kann auch ohne ihn implementiert werden, wenn jemand darin verkrampft ist.
Es gibt keine grundsätzlichen Beschränkungen in MT5.
Welche Mechanismen der Parallelisierung von Berechnungen auf der CPU in mql5 sind Ihnen bekannt?
1...337633773378337933803381338233833384338533863387338833893390...3399
Neuer Kommentar