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

Novo comentário
 
Andrey Dik #:

Sim, Sanych escreveu que não há extremos ali, e ele estava errado, pois qualquer função tem extremos.

Extremo é o ponto em que uma função atinge o maior (máximo) ou o menor (mínimo) valor em um determinado intervalo ou em uma determinada área. Os extremos podem ser locais, quando a função atinge um valor extremo somente em alguma vizinhança de um ponto, ou globais, quando a função atinge um valor extremo em todo o intervalo ou em uma determinada área.

Os extremos estão sempre presentes, mesmo que você não os procure intencionalmente (os algoritmos que você usa fazem essa operação de busca para você). O aprendizado sem otimização é impossível, e a otimização é impossível sem as atribuições corretas de FF. Se a busca por extremos for feita para você e estiver oculta (costurada no algoritmo), isso não significa que eles não existam (tanto os extremos quanto a otimização).

Não há nenhuma função nesse caso.

Por favor, chega de informações sobre bilheteria. Eu sei o que é otimização.
 
mytarmailS #:

assim?

E ele pode realmente lidar com um milhão de condições?

Estou um pouco perdido com essas coisas de switch e C++.

As duas primeiras funções são implementações do R, e a última é o switch em C++.

Unit: microseconds
                              expr    min     lq      mean median     uq       max neval
     rule(n = sample(1:200, 1), x) 40.482 44.473  57.18044 46.754 51.886  2688.931  1000
    rule2(n = sample(1:200, 1), x) 29.079 35.351 567.03671 38.202 43.904 86712.314  1000
 rule_cpp(n = sample(1:200, 1), x) 31.360 34.781  53.26793 36.491 40.482  4924.005  1000

De fato, não há nenhum ganho, como pode ser isso?...
 
mytarmailS #:

Estou um pouco perdido com essa questão de switch e C++.

As duas primeiras funções são implementações do R, a última é o switch em C++.

De fato, não há nenhum ganho, como pode ser...?

Você pode me mostrar o código?

Provavelmente você está desperdiçando uma função quando a resposta já foi recebida...

 
Aleksey Vyazmikin #:

Você pode me mostrar o código?

Provavelmente você está executando a função em vão, quando a resposta já foi recebida...

O código é o mesmo que eu publiquei, exceto pelo fato de eu ter criado as regras 300 em vez de 5.

Qual é o objetivo de postar o código?
Eu já decidi sobre a arquitetura
 
mytarmailS #:
O código é o mesmo que você postou, exceto pelo fato de eu ter definido as regras como 300 em vez de 5

Qual é o objetivo de postar o código R?
Eu já decidi sobre a arquitetura

A questão está no código da chamada de função.

 
Aleksey Vyazmikin #:

A questão está no código de chamada da função.

Não estou entendendo
 
mytarmailS #:

Basicamente, não há ganho algum, como isso pode ser...

Há muitas coisas que podem ser. O script está anexado, abaixo está a parte da função.

bool Rule0( const vector<double> &x ) { return(x[3] > x[4]); }
bool Rule1( const vector<double> &x ) { return(x[0] < x[4]); }
bool Rule2( const vector<double> &x ) { return(x[1] >= x[0]); }
bool Rule3( const vector<double> &x ) { return(x[3] == x[4]); }
bool Rule4( const vector<double> &x ) { return(x[0] != x[4]); }
bool Rule5( const vector<double> &x ) { return(x[1] >= x[0]); }
bool Rule6( const vector<double> &x ) { return(x[3] <= x[4]); }
bool Rule7( const vector<double> &x ) { return(x[0] < x[4]); }
bool Rule8( const vector<double> &x ) { return(x[1] >= x[0]); }
bool Rule9( const vector<double> &x ) { return(x[3] <= x[4]); }

bool rule3( const int n, const vector<double> &x )
{
  typedef bool (*RULE)( const vector<double>& );
  static const RULE Rules[] = {Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9,
                               Rule0, Rule1, Rule2, Rule3, Rule4, Rule5, Rule6, Rule7, Rule8, Rule9};

  return(Rules[n](x));
}

#define  BENCH(A)                                                              \
  StartTime = GetMicrosecondCount();                                          \
  A;                                                                          \
  Print(#A + " - " + (string)(GetMicrosecondCount() - StartTime) + " mcs");

void OnStart()
{
  const vector<double> x = {1, 2, 3, 4, 5};
  int Tmp = 0;

  ulong StartTime;

  BENCH(for (uint i = 1 e8; (bool)i--;) Tmp += rule(i % 100, x));
  BENCH(for (uint i = 1 e8; (bool)i--;) Tmp += rule2(i % 100, x));
  BENCH(for (uint i = 1 e8; (bool)i--;) Tmp += rule3(i % 100, x));
//  BENCH(for (uint i = 1e8; (bool)i--;) Tmp += rule(i % 100, x));  // Если добавить эту строку, то выше rule замедлится.
//  BENCH(for (uint i = 1e8; (bool)i--;) Tmp += rule2(i % 100, x)); // Если добавить эту строку, то выше rule2 замедлится.
//  BENCH(for (uint i = 1e8; (bool)i--;) Tmp += rule3(i % 100, x)); // Если добавить эту строку, то выше rule3 замедлится.

  Print(Tmp);
}


Resultado.

for (uint i = 1 e8; (bool)i--;) Tmp += rule(i % 100, x) - 505436 mcs
for (uint i = 1 e8; (bool)i--;) Tmp += rule2(i % 100, x) - 261261 mcs
for (uint i = 1 e8; (bool)i--;) Tmp += rule3(i % 100, x) - 709846 mcs


Não está claro o que é medido aqui - veja os comentários destacados. Supostamente muito mais rápido do que a regra2.

Arquivos anexados:
Switch_VS_Func.mq5  10 kb
 
fxsaber #:

É interessante notar que, em termos de quantidade de dados (citações), o cérebro humano (como uma rede neural) comparado ao MO é como um infusório comparado a um humano.

No entanto, os seres humanos primitivos provaram que podem criar TCs que funcionam muito bem. Acontece que não é necessária uma quantidade tão grande de dados para criar uma CT funcional.

É um mistério para mim como, por exemplo, o homem chegou ao ponto de criar modelos de scalper funcionais. Isso foi feito quase que totalmente sem os calculadores de números.


O cenário para isso era aparentemente mais ou menos assim:

  1. Frequentemente, vejo algum tipo de achatamento (estou estupidamente moendo a tela há alguns dias).
  2. Tentarei ganhar dinheiro com isso com um TS primitivo.
  3. Ele não drena muito. Devo refinar um pouco o TS. Dei uma olhada no histórico de negociações - parece que algo pode ser melhorado.
  4. Começou a se acumular um pouco. Repito o ponto 3.
Não usei o triturador de números. Apenas olhei para o ponto 1 e comecei a fazer isso. A probabilidade dessa abordagem parece ser quase zero, mas de alguma forma funciona. Algum tipo de método de "cutucar os loucos" que funciona.


Aparentemente, em algum subconsciente, o cérebro humano ainda é capaz de encontrar "padrões" em uma quantidade extremamente pequena de dados. Não se pode chamar isso de sorte. É um mistério.

Na minha opinião, todo o segredo está na transferência de experiência, tudo o que é novo é construído com base nas conquistas da geração anterior. Veja os processadores modernos. Para as pessoas do século XIX, isso será mágico. Para o século XX, será uma tecnologia muito complexa que não terá as ferramentas certas para fazer engenharia reversa. Somente por meio da transferência de conhecimento e do desenvolvimento gradual poderemos atingir o nível moderno de tecnologia. É por isso que dizem que, se houver a 3ª Guerra Mundial, eles lutarão com pedras na 4ª Guerra Mundial. Há lendas sobre negociação, segundo as quais os mercados anteriores eram muito mais fáceis, e os comerciantes do zênite faziam fortunas com a ajuda de médias móveis.

 
fxsaber #:

Não está muito claro o que está sendo medido aqui - veja os comentários destacados. Supostamente muito mais rápido do que a regra2.

Aqui essa função e suas diferentes implementações (equivalentes), incluindo aquelas em C++, foram medidas.

Bem, eu já decidi sobre a arquitetura por enquanto, vou me sentar no R-ke puro por enquanto, encontrei uma maneira de acelerar 25 vezes + ainda há vantagens/razões fortes para não adicionar C++ ao meu código.

 

Você pode ter um desafio com meu AMO.

"Resolva o TS".


Você me fornece uma pequena parte dos dados que usa.

Descreva quais operadores, funções e variáveis você usa no código.

E me dê sua equidade ou sinais do algoritmo.


Eu crio uma gramática de pesquisa e pego o código como uma cifra e resolvo sua TS.

1...329432953296329732983299330033013302330333043305330633073308...3399
Novo comentário