L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 3279

Nouveau commentaire
 
Alexander Ivanov #:
et je n'ai pas peur.

Et c'est vrai.

 
Grigori.S.B #:

Et ce à juste titre.

Les nouvelles du monde réel seront tristes.

 

J'essaie de trouver rapidement des chaînes courtes similaires dans une chaîne longue.

Est-il possible d'utiliser Alglib de manière optimale ?

#include <Math\Alglib\statistics.mqh> // https://www.mql5.com/ru/code/11077

const vector<double> GetCorr( const CMatrixDouble &Matrix, const vector<double> &Pattern )
{
  CMatrixDouble Vector;
  CMatrixDouble Corr;
  
  Vector.Col(0, Pattern);

  CBaseStat::PearsonCorrM2(Vector, Matrix, Matrix.Rows(), 1, Matrix.Cols(), Corr);
  
  return(Corr.Row(0));
}

#property script_show_inputs

input int inRows = 300; // Длина короткой строки
input int inCols = 1000000; // Длина длинной строки

void FillArray( double &Array[], const int Amount )
{
  for (uint i = ArrayResize(Array, Amount); (bool)i--;)
    Array[i] = MathRand();
}

void FillMatrix( CMatrixDouble &Matrix, const double &Array[], const int Rows )
{
  Matrix.Resize(Rows, ArraySize(Array) + 1 - Rows);

  double ColArray[];
  vector<double> Vector;
  
  for (uint i = (uint)Matrix.Cols(); (bool)i--;)
  {
    ArrayCopy(ColArray, Array, 0, i, Rows);
    Vector.Swap(ColArray);
    
    Matrix.Col(i, Vector);
  }
}

void FillData( double &Array[], double &Pattern[], CMatrixDouble &Matrix, const int Rows, const int Cols )
{
  FillArray(Array, Cols + Rows - 1);
  FillArray(Pattern, Rows);

  FillMatrix(Matrix, Array, Rows);    
}

#define  TOSTRING(A) #A + " = " + (string)(A) + " "

// Поиск похожей строки в длинной строке.
void OnStart()
{  
  if (inRows < inCols)
  {
    PrintCPU(); // https://www.mql5.com/ru/forum/86386/page3256#comment_49538685
    
    double Array[]; // Длинная строка, где будет искать.
    double Pattern[]; // Короткая строка, с которой будем сравнивать.
    CMatrixDouble Matrix;
    
    FillData(Array, Pattern, Matrix, inRows, inCols); // Заполнили данные.
            
    Print(TOSTRING(inRows) + TOSTRING(inCols));

    vector<double> vPattern;  
    vPattern.Assign(Pattern);

    ulong StartTime, StartMemory; // https://www.mql5.com/ru/forum/86386/page3256#comment_49538685

    BENCH(vector<double> Vector1 = GetCorr(Matrix, vPattern))
//    BENCH(vector<double> Vector2 = GetCorr(Array, Pattern))
  
//    Print(TOSTRING(IsEqual(Vector1, Vector2)));
  }      
}


Résultat.

EX5: 4000 AVX Release.
TerminalInfoString(TERMINAL_CPU_NAME) = Intel Core i7-2700 K  @ 3.50 GHz 
TerminalInfoInteger(TERMINAL_CPU_CORES) = 8 
TerminalInfoString(TERMINAL_CPU_ARCHITECTURE) = AVX 
inRows = 300 inCols = 1000000 
vector<double> Vector1 = GetCorr(Matrix, vPattern) - 6725703 mcs, 8 MB

En plus de six secondes, une telle implémentation via Alglib recherche des chaînes courtes similaires (300) dans la millionième chaîne. NumPy peut le faire ?

 
fxsaber #:

Essayer de trouver rapidement des chaînes courtes similaires dans une longue chaîne.

Est-il plus optimal d'utiliser Alglib ?


Résultat.

En plus de huit secondes, une telle implémentation via Alglib recherche la millionième chaîne de caractères similaire à la chaîne courte (300). NumPy peut le faire ?

Et comment allez-vous évaluer la matrice obtenue ? Je ne comprends pas le principe d'une telle évaluation.

 
Forester #:
Et comment allez-vous évaluer la matrice 300*1000000 qui en résulte ? Je ne comprends pas le principe d'une telle estimation.

  1. Une ligne pour 1 000 000.
  2. Nous prenons des valeurs dans l'intervalle [0..299] et les plaçons dans la première colonne de la matrice 300x1000000.
  3. On prend des valeurs dans l'intervalle [1..300] et on les met dans la deuxième colonne de la matrice 300x1000000.
  4. Et ainsi de suite.
La corrélation de cette matrice avec un certain modèle à 300 est calculée. La sortie est le millionième vecteur des coefficients de Pearson correspondants.
 
fxsaber #:
Il faut plus de six secondes à cette implémentation pour rechercher dans Alglib une millionième chaîne similaire à une chaîne courte .

J'ai également une moyenne d'environ 6 secondes.

J'ai fait plusieurs essais.

 system.time({
+   find_cor(y,x)
+ })
   user  system elapsed 
   4.15    0.03    5.70 
> system.time({
+   find_cor(y,x)
+ })
   user  system elapsed 
   4.38    0.02    5.16 
> system.time({
+   find_cor(y,x)
+ })
   user  system elapsed 
   4.18    0.01    6.10 
> system.time({
+   find_cor(y,x)
+ })
   user  system elapsed 
   4.08    0.00    5.99

mais je l'ai fait de la manière la plus habituelle, je n'ai pas cherché de solution scientifique.

 
mytarmailS #:

Moi aussi, j'ai une moyenne de six secondes.

J'ai fait quelques courses

mais je l'ai fait de la manière habituelle, je n'ai pas cherché de solutions miracles.

Quel type de R avez-vous ?

R de Microsoft utilise la bible d'Intel pour les vecteurs et les matrices....

 
СанСаныч Фоменко #:

Quel est votre R ?

Microsoft R utilise la bible Intel pour les vecteurs et les matrices....

régulier...

mais j'ai écrit la fonction en C++ dans R.

 
mytarmailS #:

ordinaire

Je me demande si Microsoft R + intel = ponts ou vraiment plus rapide ?

 
СанСаныч Фоменко #:

Je me demande si Microsoft R + Intel = ponts ou vraiment plus rapide ?

Je n'ai jamais essayé, mais je suis curieux.

Mais je suis intéressé par une augmentation générale de la vitesse sur n'importe quelle action, pas seulement sur les matrices et les vecteurs.

1...327232733274327532763277327832793280328132823283328432853286...3399
Nouveau commentaire