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

Nuovo commento
 
mytarmailS #:

Utilizzate la regressione simbolica, progettate esattamente quello che volete, non quello che suggeriscono gli altri algoritmi.

Conoscete Rku, c'è un pacchetto, ci sono esempi, tutto è stato fatto prima e per noi.

Ci sto lavorando. Non c'è ancora il Graal)

 
elibrarius #:
Se solo 1 e 2 possono interagire. Oppure 3,4,5. Quindi, dopo la prima divisione, ad esempio su 3, tutte le divisioni successive saranno solo dall'insieme 3,4,5.
Suppongo che sia sufficiente costruire 2 alberi a partire dagli insiemi 1,2 e 3,4,5. Se ci sono 10 insiemi, allora ci sono 10 alberi. E così via.

È anche possibile unire gruppi in gruppi - si ottiene un albero (elenco di elenchi di elenchi di elenchi di elenchi...).

Il principio generale della costruzione di tali gruppi nel nostro caso non è del tutto chiaro.

 
Aleksey Nikolayev #:

Ci sto lavorando. Non c'è ancora il Graal).

State padroneggiando il pacchetto grammEvol?

 
mytarmailS #:
Stai ricevendo il pacchetto grammEvol?

gramEvol? Se si tratta di grammatiche, sono necessarie grammatiche parametriche, in cui le regole hanno parametri numerici per i quali devono essere ottimizzate. A prima vista non li ho visti nel pacchetto. Intendo ottenere non solo le regole x1-x2*x3<0, ma tutte le possibili regole della forma A<x1-x2*x3<B, dove x1, x2, x3 sono predittori, A e B sono parametri.

No, sto armeggiando al livello più basso, con Rcpp, cercando di trovare la matematica giusta.

 
Aleksey Nikolayev #:

A prima vista non li ho visti nella confezione.

C'è tutto. Tutto ciò che si può pensare può essere implementato lì.

Guardate gli esempi delle vignette, guardate il gthub dell'autore nelle domande, ho fatto molte domande sulle regole anche lì.
 
mytarmailS #:
Tutto è lì. Tutto ciò che si può pensare può essere realizzato lì.

Guardate gli esempi delle vignette, guardate il gthub dell'autore nelle domande, ho fatto molte domande sulle regole anche lì.

Grazie, darò un'occhiata più da vicino quando avrò tempo.

 
Aleksey Nikolayev #:

Grazie, darò un'occhiata più da vicino quando avrò tempo.

Questo è in realtà un costruttore di codice, si impostano solo gli elementi necessari.

Cioè, può scrivere da solo del vero codice, con cicli, array, tutto, tutto....

E poiché può scrivere codice, può scrivere qualsiasi cosa, l'unico limite è la vostra immaginazione, beh, e la vostra capacità di deduzione, naturalmente.

 
Aleksey Nikolayev #:

gramEvol? Se si parla di grammatiche, abbiamo bisogno di grammatiche parametriche, in cui le regole hanno parametri numerici per i quali devono essere ottimizzate. A prima vista non le ho viste nel pacchetto. Intendo ottenere non solo le regole x1-x2*x3<0, ma tutte le possibili regole della forma A<x1-x2*x3<B, dove x1, x2, x3 sono predittori, A e B sono parametri.

No, sto armeggiando al livello più basso, con Rcpp, cercando di trovare la matematica giusta.

Non so se ho capito bene, ho scritto un semplice esempio sbattendo un po' la testa contro il monitor.

library(gramEvol)
ruleDef <- list(
  logyc_exp     = grule(comparison(big_math_expr, parameters)),
  comparison    = grule(">=","<=","!=","=="),
  parameters    = grule(100,200,300),  #   A и B - параметры.
  
  
  big_math_expr = grule( math_expr,  math_oper(math_expr, math_expr)),
  math_expr     = grule(math_oper(predictors, predictors)),
  math_oper     = grule("+", "-", "*","/"),
  predictors    = grule(x1,x2,x3,x4) #   где x1, x2, x3 - предикторы
  )

grammarDef <- CreateGrammar(ruleDef)
GrammarRandomExpression(grammarDef,numExpr = 10)

È questo che volevi?

[[1]]
expression(x4 * x1 + (x2 + x4) <= 100)

[[2]]
expression(x1/x3 * (x4/x1) >= 300)

[[3]]
expression(x2/x1 + x1 * x1 != 300)

[[4]]
expression(x4 - x3 + (x3 + x1) != 100)

[[5]]
expression(x2/x1/(x2 + x1) != 300)

[[6]]
expression(x3/x1 + (x3 + x3) >= 100)

[[7]]
expression(x1 * x1 >= 200)

[[8]]
expression(x3/x2 - x3/x2 <= 100)

[[9]]
expression((x3 + x4)/(x4 - x1) <= 300)

[[10]]
expression(x3/x1 <= 200)
 
mytarmailS #:

Non so se ho capito bene, ho scritto un semplice esempio dopo aver battuto un po' la testa contro il monitor.

È questo che volevi?

Sembra di sì, ma sembra che i parametri possano assumere solo alcuni valori specificati, non un numero reale arbitrario.

 
Aleksey Nikolayev #:

Simile, ma sembra che i parametri possano assumere solo alcuni valori, non un numero reale arbitrario.


my_var <- round(seq(-10,10,length.out = 100),2)

library(gramEvol)
ruleDef <- list(
  logyc_exp     = grule(comparison(big_math_expr, parameters)),
  comparison    = grule(">=","<=","!=","=="),
  #parameters    = grule(100,200,300),  #   A и B - параметры.
  parameters    = do.call(gsrule, as.list(my_var)),  #   A и B - параметры.
  
  
  big_math_expr = grule( math_expr,  math_oper(math_expr, math_expr)),
  math_expr     = grule(math_oper(predictors, predictors)),
  math_oper     = grule("+", "-", "*","/"),
  predictors    = grule(x1,x2,x3,x4) #   где x1, x2, x3 - предикторы
)

grammarDef <- CreateGrammar(ruleDef)
GrammarRandomExpression(grammarDef,numExpr = 10)
[[1]]
expression(x1 - x2 != 9.6)

[[2]]
expression(x3 + x1 != 9.8)

[[3]]
expression(x2 - x1 - x1 * x1 == 9.8)

[[4]]
expression(x4/x3 - (x2 - x3) != 8.59)

[[5]]
expression(x4 + x2 >= -8.18)

[[6]]
expression((x1 - x4)/(x3 * x2) <= 6.57)

[[7]]
expression(x2 - x1 >= 1.92)

[[8]]
expression(x1 * x3 + x3/x4 != -2.93)


È meglio?


=====================

È anche possibile complicare le espressioni

library(gramEvol)
ruleDef <- list(
  
  final_exp     = grule(logyc_exp , logyc_exp | logyc_exp , logyc_exp & logyc_exp),
  
  
  logyc_exp     = grule(logyc_oper(big_math_expr, parameters),
                        logyc_oper(big_math_expr, big_math_expr)),
  
  
  logyc_oper    = grule(">=","<=","!=","=="),
  parameters    = do.call(gsrule, as.list(my_var)),  #   A и B - параметры.
  
  
  big_math_expr = grule( math_expr,  math_oper(math_expr, math_expr)),
  math_expr     = grule(math_oper(predictors, predictors)),
  math_oper     = grule("+", "-", "*","/"),
  predictors    = grule(x1,x2,x3,x4) #   где x1, x2, x3 - предикторы
)

grammarDef <- CreateGrammar(ruleDef)
GrammarRandomExpression(grammarDef,numExpr = 10)

[[1]]
expression(x3 * x2 <= x2 * x3 - (x4 - x4))

[[2]]
expression(x2/x1 != x3 - x1 | (x1 + x3)/(x1 * x3) >= -9.6)

[[3]]
expression(x4 + x3 - (x2 - x2) >= 3.94 & x3 * x2 * (x1 - x3) == x2 * x1)

[[4]]
expression(x3 * x3 - x2 * x4 == -6.97)

[[5]]
expression(x4 * x4 - (x1 + x4) <= x4/x4 - x3/x2 | (x3 + x1)/(x4 - x1) >= x2 * x3)

[[6]]
expression(x2 + x3 + x2/x1 != -3.74)

[[7]]
expression((x1 - x2)/(x2 + x1) <= (x3 - x3)/(x2 - x1) & x4/x2 - x4 * x2 <= 6.97)
1...264326442645264626472648264926502651265226532654265526562657...3399
Nuovo commento