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

[Aleksey Nikolayev]

mytarmailS #:

Use a regressão simbólica, projete exatamente o que você deseja e não o que outros algoritmos sugerem.

Você conhece o Rku, há um pacote, há exemplos, tudo já foi feito antes e para nós.

Estou trabalhando nisso. Ainda não há um graal)

[Aleksey Nikolayev]

elibrarius #:
Se apenas 1 e 2 puderem interagir. Ou 3,4,5. Então, após a primeira divisão, por exemplo, em 3, todas as divisões posteriores serão apenas do conjunto 3,4,5.
Presumo que isso simplesmente construa 2 árvores a partir dos conjuntos 1,2 e 3,4,5. Se houver 10 conjuntos, então haverá 10 árvores. E assim por diante.

Também é possível mesclar grupos em grupos - você obtém uma árvore (lista de listas de listas de listas de listas de listas...).

O princípio geral da criação desses grupos em nosso caso não é muito claro.

[mytarmailS]

Aleksey Nikolayev #:

Estou trabalhando nisso. Ainda não há um graal).

Você está dominando o pacote grammEvol?

[Aleksey Nikolayev]

mytarmailS #:
Você está recebendo o pacote grammEvol?

gramEvol? Em termos de gramáticas, você precisa de gramáticas paramétricas, em que as regras têm parâmetros numéricos a serem otimizados. À primeira vista, não as vi no pacote. Quero dizer, não apenas as regras x1-x2*x3<0, mas todas as regras possíveis da forma A<x1-x2*x3<B, em que x1, x2, x3 são preditores, A e B são parâmetros.

Não, estou mexendo no nível mais baixo - com o Rcpp, tentando encontrar a matemática certa.

[mytarmailS]

Aleksey Nikolayev #:

À primeira vista, não os vi na embalagem.

Tudo está lá. Tudo o que você pode imaginar pode ser implementado lá.

Dê uma olhada nos exemplos das vinhetas, dê uma olhada no gthub do autor nas perguntas, eu fiz muitas perguntas sobre as regras lá também

[Aleksey Nikolayev]

mytarmailS #:
Tudo está lá. Qualquer coisa que você possa imaginar pode ser realizada lá.

Dê uma olhada nos exemplos das vinhetas, dê uma olhada no gthub do autor nas perguntas, eu fiz muitas perguntas sobre as regras lá também

Obrigado, darei uma olhada mais de perto quando tiver tempo.

[mytarmailS]

Aleksey Nikolayev #:

Obrigado, darei uma olhada mais de perto quando tiver tempo.

Na verdade, trata-se de um construtor de código, em que você só define os elementos de que precisa.

Ou seja, ele pode escrever código de verdade, com ciclos, matrizes, tudo, tudo....

E como ele pode escrever código, pode escrever qualquer coisa, o único limite é sua imaginação, bem, e seu poder de dedução, é claro.

[mytarmailS]

Aleksey Nikolayev #:

gramEvol? Em termos de gramáticas, precisamos de gramáticas paramétricas, em que as regras têm parâmetros numéricos a serem otimizados. À primeira vista, não as vi no pacote. Quero dizer, não apenas as regras x1-x2*x3<0, mas todas as regras possíveis da forma A<x1-x2*x3<B, em que x1, x2, x3 são preditores, A e B são parâmetros.

Não, estou mexendo no nível mais baixo - com o Rcpp, tentando encontrar a matemática certa.

Não sei se o entendi corretamente, escrevi um exemplo simples batendo um pouco a cabeça no 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)

Era isso que você queria?

[[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)

[Aleksey Nikolayev]

mytarmailS #:

Não sei se o entendi corretamente. Escrevi um exemplo simples depois de bater um pouco a cabeça no monitor.

Era isso que você queria?

Parece que sim, mas parece que os parâmetros só podem ter alguns valores especificados, não um número real arbitrário.

[mytarmailS]

Aleksey Nikolayev #:

Semelhante, mas parece que os parâmetros só podem assumir alguns valores determinados, não um número real arbitrário.

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)

Isso é melhor?

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

Você também pode complicar as expressões

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)