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

Novo comentário
 
elibrarius #:

Aparentemente, eles reservaram palavras para os novos tipos.

Não apenas reservado, algumas coisas já estão a funcionar.

void OnStart()
{
  vector v(3);
  v[0] = 1.0;
  v[1] = 2.0;
  v[2] = 3.0;
  matrix m(3, 3);
  m.Random();
  Print("m = ", m);
  Print("m^-1 = ", m.Inverse());
  Print("Det(m) = ", m.Det());
  Print("m * v = ", m * v);
}
 
Aleksey Nikolayev #:

Não só reservado, algo já está a funcionar.

A busca de ajuda não rende nada.
E as matrizes virão a calhar.
A definição de um tamanho através de variáveis funciona

int m1=2; int m2=2;
matrix m(m1, m2);

Antes de teres de te preocupar com arrays dinâmicos.

 
elibrarius #:

A busca de ajuda não dá nada.

Eu só tenho informações daqui.

elibrarius #:

E as matrizes virão a calhar.
Trabalho com variáveis para definir o tamanho

int m1=2; int m2=2;
matrix m(m1, m2);

Antes de teres de usar arrays dinâmicos.

Na verdade, Renat prometeu aprendizagem da máquina em MQL5, como o suporte ONNX. Vamos ver)

 
Vladimir Baskakov #:
Nunca ninguém venceu a intersecção dos dois mash-ups

... e o atraso pode ser reduzido por um prefixo NS))

 
elibrarius #:
Se alguém usa o pacote do SanSanych para se conectar ao R, então:

No arquivo R.mqh, os nomes das variáveis vetoriais e matriciais começaram a dar um erro durante a compilação. Renomeie-os para outros nomes e tudo vai funcionar. Eu usei vectr e matr.

O editor destaca estas palavras em azul como um tipo de dado como int, duplo. Palavras aparentemente reservadas para novos tipos.

Hmm, não sabia nada sobre esta biblioteca. Como utilizá-lo, qual é a sua funcionalidade?

 
iwelimorn #:

Em resumo, tudo em vão, com MO o mercado não pode ser enganado.

Encontrei os traços e o alvo, cuja distribuição de classe é mostrada na primeira figura.

A exatidão dos modelos de teste e treinamento de katbust treinados com este conjunto de dados foi de 93%.

A segunda figura mostra o saldo e o gráfico de equidade do comércio alvo:

A terceira figura mostra o balanço e o gráfico de equidade da negociação sobre os sinais do modelo treinado de katbusta:

Por isso, senhoras e senhores, dispersem.

Qual é o alvo, como é que o encontrou?

Já tentaste adicionar um carrinho de compras?

Se você olhar apenas para o saldo de erros (+1 certo -1 errado para a classe 1), o resultado é muito diferente?

 
Aleksey Vyazmikin #:

Hmm, não sabia nada sobre esta biblioteca. Como utilizá-lo, qual é a sua funcionalidade?


Transmissão bidireccional de variáveis e matrizes entre MT e R. Há citações, resultados anteriores e comandos.
Descrição da função:
/***
* Devolver a versão dll. Os 16 bits superiores do valor de retorno
* são a versão maior e os 16 bits inferiores a menor. Este
* é usado em RInit() para garantir que este arquivo de cabeçalho e
* zzthe dll encaixem juntos.
*/
int RGetDllVersion();

/**
* Isto não é para ser chamado diretamente, será
* chamado por RInit() após a verificação bem sucedida da versão.
* Você deve chamar RInit() para iniciar uma nova sessão R.
*/
long RInit_(string commandline,int debuglevel);

/***
* Tema a sessão R. Chame isto na sua função deinit().
* Depois disso, o cabo não é mais válido.
*/
void RDeinit(long rhandle);

/**
* return true se a sessão R pertencente a este cabo for
* ainda em execução. R terminará em qualquer erro fatal no código
* que você enviar. Você deve verificar isso no início
* da sua função de início e parar todas as ações. O último comando
* antes do acidente será encontrado no log.
* Se R não estiver mais rodando, esta biblioteca não emitirá mais
* mais mensagens de log e ignorará silenciosamente todos os comandos.
*/
bool RIsRunning(long rhandle);

/**
* return true if R ainda está executando um comando (resultante
* de uma chamada para RExecuteAsync())
*/
bool RIsBusy(long rhandle);

/**
* execute o código e não espere. Qualquer chamada subsequente, no entanto
* irá esperar, uma vez que só pode haver uma thread executando em
* a qualquer momento. Use RIsBusy() para verificar se está terminado
*/
void RExecuteAsync(long rhandle,string code);

/***
* execute o código e espere até que ele esteja terminado. Isto não irá
* devolver nada. Você pode basicamente conseguir o mesmo com
* as funções RGet*(), avaliando a expressão também é
* apenas executando código, a única diferença é que estas funções
* RGet*() irão adicionalmente tentar analisar e retornar
* a saída enquanto RExecute() irá apenas executar, esperar e
* ignorar toda a saída.
*/
void RExecute(long rhandle,string code);

/***
* atribuir um bool ao nome da variável. Em R este tipo é chamado de "lógico"
*/
void RAssignBool(long rhandle,string variable,bool value);

/**
* atribuir um inteiro ao nome da variável.
*/
void RAssignInteger(long rhandle,string variable,int value);

/***
* atribuir um duplo ao nome da variável.
*/
void RAssignDouble(long rhandle,string variable,double value);

/***
* atribuir uma string ao nome da variável. Em R este tipo é chamado "character"
*/
void RAssignString(long rhandle,string variable,string value);

/**
* atribui um vector ao nome da variável. Se o tamanho não corresponder a
* o tamanho real do seu array pode acontecer coisas ruins.
*/
void RAssignVector(long rhandle,string variable,double &vectr[],int size);

/***
* atribui um vector de caracteres (um array de strings) à variável. Se você precisa de
* um fator, então você deve executar o código para convertê-lo após este comando. Em
* versões recentes de R um vector de cordas não precisa de mais memória do que
* um factor e é mais fácil anexar-lhe novos elementos.
*/
void RAssignStringVector(long rhandle,string variable,string &vectr[],int size);

/***
* atribuir uma matriz ao nome da variável. A matriz deve ter o número da linha como a
* primeira dimensão (byrow=TRUE será usado nos dados brutos). Esta função é muito mais rápida
* do que construir uma matriz enorme (centenas de linhas) do zero, anexando
* novas linhas no final com RRowBindVector() para cada linha. Esta função é otimizada
* para uma enorme taxa de transferência com uma única chamada de função através de file-IO com o
* dados binários brutos. Para matrizes e vectores muito pequenos com apenas um punhado de elementos
* isto pode ser demasiado dispendioso e as outras funções serão mais rápidas. Uma vez que você
* tenha a matriz com possivelmente milhares de linhas transferidas para R você deve então
* usar apenas RRowBindVector() para crescer mais lentamente com a chegada de novos vetores de dados
* em vez de sempre enviar uma nova cópia de toda a matriz.
*/
void RAssignMatrix(long rhandle,string variable,double &matr[],int rows,int cols);

/***
* anexar uma linha a uma matriz ou dataframe. Isto irá exutar
* variável <- rbind(variável, vetor)
* se o tamanho não corresponder ao tamanho real do array podem acontecer coisas ruins.
*/
void RAppendMatrixRow(long rhandle,string variable,double &vectr[],int size);

/***
* return true if the variable exists, false otherwise.
*/
bool RExists(long rhandle,string variable);

/***
* avaliar expressão e devolver um bool. A expressão pode ser qualquer código R
* que avaliará à lógica. Se for um vector de lógica então apenas
* o primeiro elemento é devolvido.
*/
bool RGetBool(long rhandle,string expression);

/***
* avaliar a expressão e devolver um inteiro. Uma expressão pode ser qualquer código R
* que avaliará a um número inteiro. Se for um ponto flutuante será
* arredondado, se for um vector então apenas o primeiro elemento será devolvido.
*/
int RGetInteger(long rhandle,string expression);

/***
* avaliar a expressão e devolver um duplo. A expressão pode ser qualquer código R
* que irá avaliar para um número de ponto flutuante, se for um vector então
* apenas o primeiro elemento é devolvido.
*/
double RGetDouble(long rhandle,string expression);

/***
* avaliar a expressão e devolver um vector de duplas. A expressão pode
* ser qualquer coisa que avalia a um vector de números de ponto flutuante.
* Valor de retorno é o número de elementos que podem ser copiados para a matriz
*. Nunca será maior que o tamanho, mas pode ser menor.
* os avisos são emitidos no nível de depuração 1 se os tamanhos não corresponderem.
>>> Limitado a 100000 elementos
*/
int RGetVector(long rhandle,string expression,double &vectr[],int size);

/***
* fazer uma impressão(expressão) para fins de depuração. A saída será
* enviado para o monitor de depuração no nível de depuração 0.
*/

void RPrint(long rhandle,string expression);

 
elibrarius #:

Transferência bidireccional de variáveis e matrizes entre MT e R. Há citações, resultados anteriores e comandos.
Obrigado pela informação, estará atento a esta possibilidade. Qual é o atraso de uma viagem de ida e volta, afinal?
 
Aleksey Vyazmikin #:
Obrigado pela informação, eu estarei ciente desta possibilidade. Quanto tempo demora a viagem de ida e volta?
Muito rápido. Através da troca de memória. Não arquivos ou pips.
 
Vladimir Baskakov #:
Nunca ninguém venceu a intersecção das duas formas de onda.
Você não vai acreditar.
Se for usada a média, o resultado será idêntico ao das zaragatoas, e o tempo de capotamento do sinal será o mesmo para dentro de segundos.
---
Eu próprio fiquei chocado ;)
1...250325042505250625072508250925102511251225132514251525162517...3399
Novo comentário
Razão: